@rcarls/rc-adaptive-menu 0.5.0

package/dist/rc-adaptive-menu-BwvfkD_X.js

@@ -0,0 +1,589 @@
+import { css as w, LitElement as y, html as x } from "lit";
+import { property as p, query as b } from "lit/decorators.js";
+import { AnchorController as O, keyNavigation as d, isFocusable as g } from "@rcarls/rc-common";
+const A = w`
+  :host {
+    display: block;
+    inline-size: fit-content;
+    /*
+     * Raised past 100% by exactly the overlap amount so the cap only ever
+     * bounds the host's own visible content, not the content plus the
+     * intentional negative-margin overhang below. Inside a shrink-to-fit
+     * flex/grid ancestor (a toolbar's trailing group, for example) the
+     * ancestor's own auto size already accounts for the negative margin,
+     * so a plain 100% cap would re-clamp the host down to that
+     * already-shrunk size and silently cancel the overlap out from under
+     * it — confirmed live: with a plain 100% cap the host visibly shrank
+     * instead of overlapping.
+     */
+    max-inline-size: calc(
+      100% + var(--rc-adaptive-menu-touch-target-overlap-inline-start, 0px) +
+        var(--rc-adaptive-menu-touch-target-overlap-inline-end, 0px)
+    );
+    min-inline-size: 0;
+    /*
+     * Zero by default. The overflow trigger's own touch-target inflation
+     * (see #overflow-trigger-target below) is what typically leaves dead
+     * space at a real edge, such as a toolbar's trailing-most control — but
+     * the margin has to live on the host, not on that internal wrapper:
+     * #root just lays out flush with the host's own edges, so a margin
+     * placed there has no visible effect on where the host itself renders
+     * in an outer flex/grid container. The host's own box is
+     * fit-content-sized and is what an outer container's own trailing
+     * alignment actually positions, so this is the point that needs to
+     * move. A theme or consumer sets one of these on a host that sits at a
+     * real edge (no neighbor on that side) to let it overlap into whatever
+     * sits just outside, such as a container's own edge padding, instead of
+     * also reserving layout space there — the same pattern as rc-button's
+     * and rc-menu-button's own touch-target overlap tokens.
+     */
+    margin-inline-start: calc(-1 * var(--rc-adaptive-menu-touch-target-overlap-inline-start, 0px));
+    margin-inline-end: calc(-1 * var(--rc-adaptive-menu-touch-target-overlap-inline-end, 0px));
+  }
+
+  #root {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: var(--rc-adaptive-menu-gap, var(--rc-control-gap, 0.25em));
+    min-inline-size: 0;
+    max-inline-size: 100%;
+  }
+
+  :host([orientation='vertical']) {
+    inline-size: 100%;
+  }
+
+  :host([orientation='vertical']) #root {
+    flex-direction: column;
+    align-items: stretch;
+    min-block-size: 0;
+    inline-size: 100%;
+    block-size: 100%;
+  }
+
+  #actions,
+  #overflow {
+    display: contents;
+  }
+
+  #overflow-trigger-target {
+    position: relative;
+    flex: none;
+    display: grid;
+    place-items: center;
+    box-sizing: border-box;
+    min-inline-size: var(
+      --rc-adaptive-menu-touch-target-inline-size,
+      var(--rc-adaptive-menu-touch-target-block-size, 3rem)
+    );
+    min-block-size: var(--rc-adaptive-menu-touch-target-block-size, 3rem);
+  }
+
+  #overflow-trigger {
+    position: relative;
+    display: inline-grid;
+    place-items: center;
+    box-sizing: border-box;
+    min-inline-size: var(--rc-adaptive-menu-trigger-inline-size, 2.5em);
+    min-block-size: var(--rc-adaptive-menu-trigger-block-size, 2.5em);
+    padding: var(--rc-adaptive-menu-trigger-padding, 0.5em);
+    border: var(--rc-adaptive-menu-trigger-border, 1px solid ButtonBorder);
+    border-radius: var(--rc-adaptive-menu-trigger-radius, var(--rc-control-radius, 0));
+    background: var(--rc-adaptive-menu-trigger-background, ButtonFace);
+    color: var(--rc-adaptive-menu-trigger-color, ButtonText);
+    font: inherit;
+    line-height: 1;
+    cursor: pointer;
+  }
+
+  #overflow-trigger::before {
+    content: '';
+    position: absolute;
+    inset-block: calc((var(--rc-adaptive-menu-touch-target-block-size, 3rem) - 100%) / -2);
+    inset-inline: calc(
+      (
+          var(
+              --rc-adaptive-menu-touch-target-inline-size,
+              var(--rc-adaptive-menu-touch-target-block-size, 3rem)
+            ) -
+            100%
+        ) /
+        -2
+    );
+  }
+
+  :host(:not([data-overflow])) #overflow-trigger-target {
+    position: fixed;
+    visibility: hidden;
+    pointer-events: none;
+  }
+
+  #overflow-trigger:focus-visible {
+    outline: var(--rc-focus-ring, auto);
+    outline-offset: var(--rc-focus-ring-offset, 0);
+  }
+
+  #overflow-icon {
+    inline-size: var(--rc-adaptive-menu-icon-size, 1.5em);
+    block-size: var(--rc-adaptive-menu-icon-size, 1.5em);
+    fill: currentColor;
+  }
+
+  #popup {
+    position: fixed;
+    display: none;
+    flex-direction: column;
+    box-sizing: border-box;
+    min-inline-size: var(--rc-adaptive-menu-popup-min-inline-size, 10em);
+    max-inline-size: var(--rc-adaptive-menu-popup-max-inline-size, calc(100dvi - 0.5rem));
+    max-block-size: var(--rc-adaptive-menu-popup-max-block-size, calc(100dvb - 0.5rem));
+    margin: 0;
+    padding-block: var(--rc-adaptive-menu-popup-padding-block, 0.25em);
+    border: var(--rc-adaptive-menu-popup-border, var(--rc-border, 1px solid ButtonBorder));
+    border-radius: var(--rc-adaptive-menu-popup-radius, var(--rc-control-radius, 0));
+    background: var(--rc-adaptive-menu-popup-background, var(--rc-surface, Canvas));
+    box-shadow: var(
+      --rc-adaptive-menu-popup-shadow,
+      var(--rc-shadow, 0 2px 8px color-mix(in srgb, CanvasText 15%, transparent))
+    );
+    color: var(--rc-adaptive-menu-popup-color, var(--rc-field-text, CanvasText));
+    overflow: auto;
+    overscroll-behavior: contain;
+    scrollbar-gutter: stable;
+  }
+
+  #popup:is(:popover-open, [data-fallback-open]) {
+    display: flex;
+  }
+`;
+var k = Object.defineProperty, T = Object.getOwnPropertyDescriptor, c = (h, e, t, r) => {
+  for (var i = r > 1 ? void 0 : r ? T(e, t) : e, n = h.length - 1, u; n >= 0; n--)
+    (u = h[n]) && (i = (r ? u(e, t, i) : u(i)) || i);
+  return r && i && k(e, t, i), i;
+};
+const z = "rc-button, rc-chip, rc-menu-button", S = `
+@layer rc-base {
+  rc-adaptive-menu > [data-rc-action-promoted],
+  rc-adaptive-menu > [data-rc-action-overflowed] {
+    box-sizing: border-box;
+    min-inline-size: 0;
+  }
+
+  rc-adaptive-menu > [data-rc-action-overflowed] {
+    display: flex;
+    inline-size: 100%;
+  }
+
+  rc-adaptive-menu > [data-rc-action-overflowed] > :is(button, a[href]),
+  rc-adaptive-menu > :is(button, a[href])[data-rc-action-overflowed] {
+    display: flex;
+    align-items: center;
+    gap: var(--rc-adaptive-menu-item-gap, var(--rc-item-gap, 0.5em));
+    box-sizing: border-box;
+    inline-size: 100%;
+    min-block-size: var(--rc-adaptive-menu-item-min-block-size, 2.5em);
+    padding: var(--rc-adaptive-menu-item-padding-block, var(--rc-item-padding-block, 0.3em))
+      var(--rc-adaptive-menu-item-padding-inline, var(--rc-item-padding-inline, 0.75em));
+    border: none;
+    border-radius: 0;
+    background: transparent;
+    color: inherit;
+    font: inherit;
+    text-align: start;
+    text-decoration: none;
+  }
+
+  rc-adaptive-menu [data-rc-menu-leading],
+  rc-adaptive-menu [data-rc-menu-trailing] {
+    flex: none;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+  }
+
+  rc-adaptive-menu [data-rc-menu-label] {
+    flex: 1 1 auto;
+    min-inline-size: 0;
+  }
+
+  rc-adaptive-menu [data-rc-menu-trailing],
+  rc-adaptive-menu [data-rc-menu-shortcut],
+  rc-adaptive-menu [data-menu-shortcut] {
+    margin-inline-start: auto;
+  }
+}
+`;
+var s;
+const l = (s = class extends y {
+  constructor() {
+    super(...arguments), this.label = "Actions", this.maxShown = 3, this._defaultOpen = !1, this._openInitialized = !1, this.orientation = "horizontal", this.overflowLabel = "More actions", this._authored = /* @__PURE__ */ new Map(), this._applyingSlots = !1, this._restoreFocusWhenClosed = !1, this._focusWhenOpened = null, this._anchor = new O(this, {
+      anchor: () => this._$trigger,
+      floating: () => this._$popup,
+      placement: "bottom-end",
+      offset: 4,
+      shadowHost: () => this
+    }), this._onSlotChange = () => {
+      this._applyingSlots || queueMicrotask(() => {
+        this.isConnected && !this._applyingSlots && this._syncActions();
+      });
+    }, this._onMutation = (e) => {
+      if (!this._applyingSlots) {
+        if (e.some((t) => t.type === "childList" || t.attributeName === "slot")) {
+          this._syncActions();
+          return;
+        }
+        if (e.some((t) => t.attributeName === "data-priority")) {
+          this._applySlots();
+          return;
+        }
+        this._syncToolbarTabStops();
+      }
+    }, this._onFocusIn = (e) => {
+      const t = e.composedPath()[0];
+      t instanceof HTMLElement && this._promotedFocusTargets().includes(t) && this._syncToolbarTabStops(t);
+    }, this._onToolbarNavigate = (e) => {
+      this._focusByNavigationAction(e, this._promotedFocusTargets());
+    }, this._onTriggerNavigate = (e) => {
+      switch (e) {
+        case "open-to-first":
+          this._requestUserOpen(!0, !1, "first");
+          break;
+        case "open-to-last":
+          this._requestUserOpen(!0, !1, "last");
+          break;
+        case "escape":
+          this._requestUserOpen(!1, !0);
+          break;
+      }
+    }, this._onOverflowNavigate = (e) => {
+      if (e === "escape") {
+        this._requestUserOpen(!1, !0);
+        return;
+      }
+      this._focusByNavigationAction(e, this._overflowFocusTargets());
+    }, this._onTriggerClick = () => {
+      this._requestUserOpen(!this.open, !1, "none");
+    }, this._onDocumentPointerDown = (e) => {
+      this.open && !e.composedPath().includes(this) && this._requestUserOpen(!1, !1);
+    }, this._onDocumentKeydown = (e) => {
+      this.open && e.key === "Escape" && !e.composedPath().includes(this) && this._requestUserOpen(!1, !1);
+    }, this._onPopupClick = (e) => {
+      const t = e.composedPath(), r = Array.from(this._authored.entries()).find(
+        ([n, u]) => n.hasAttribute("data-rc-action-overflowed") && (t.includes(n) || t.includes(u.focusTarget))
+      );
+      if (!r || this._isDisabled(r[1].focusTarget))
+        return;
+      const i = r[1].focusTarget;
+      t.includes(i) && i.getAttribute("aria-haspopup") === "menu" || this._requestUserOpen(!1, !0);
+    };
+  }
+  get open() {
+    return this._open ?? this._uncontrolledOpen ?? this._defaultOpen;
+  }
+  set open(e) {
+    const t = this.open;
+    this._open = e, this._openInitialized = !0, this.requestUpdate("open", t);
+  }
+  get defaultOpen() {
+    return this._defaultOpen;
+  }
+  set defaultOpen(e) {
+    const t = this._defaultOpen;
+    this._defaultOpen = e, !this._openInitialized && this._open === void 0 && this._uncontrolledOpen === void 0 && this.requestUpdate("open", t), this.requestUpdate("defaultOpen", t);
+  }
+  connectedCallback() {
+    super.connectedCallback(), s._ensureBaseStyles(this.getRootNode()), this.addEventListener("focusin", this._onFocusIn), this.ownerDocument.addEventListener("pointerdown", this._onDocumentPointerDown), this.ownerDocument.addEventListener("keydown", this._onDocumentKeydown), typeof MutationObserver == "function" && (this._mutationObserver = new MutationObserver(this._onMutation), this._mutationObserver.observe(this, {
+      attributeFilter: ["aria-disabled", "data-priority", "disabled", "slot"],
+      childList: !0,
+      subtree: !0
+    })), this.hasUpdated && queueMicrotask(() => {
+      this.isConnected && (this._syncActions(), this._syncOpenState());
+    });
+  }
+  disconnectedCallback() {
+    this.removeEventListener("focusin", this._onFocusIn), this.ownerDocument.removeEventListener("pointerdown", this._onDocumentPointerDown), this.ownerDocument.removeEventListener("keydown", this._onDocumentKeydown), this._mutationObserver?.disconnect(), this._mutationObserver = void 0;
+    for (const [e, t] of this._authored)
+      this._restoreAction(e, t);
+    this._authored.clear(), super.disconnectedCallback();
+  }
+  firstUpdated() {
+    this._syncActions(), this._syncOpenState();
+  }
+  updated(e) {
+    e.has("orientation") && this._anchor.setOptions({
+      placement: this.orientation === "vertical" ? "right-start" : "bottom-end"
+    }), (e.has("maxShown") || e.has("orientation")) && this._applySlots(), e.has("open") && this._syncOpenState();
+  }
+  /** Original authored action elements in DOM order. */
+  get $actions() {
+    return this._entriesInDomOrder().map(([e]) => e);
+  }
+  /** Actions currently shown in the toolbar, in authored DOM order. */
+  get $promotedActions() {
+    return this.$actions.filter((e) => e.hasAttribute("data-rc-action-promoted"));
+  }
+  /** Actions currently assigned to the overflow menu, in authored DOM order. */
+  get $overflowedActions() {
+    return this.$actions.filter((e) => e.hasAttribute("data-rc-action-overflowed"));
+  }
+  /** Opens the overflow popup silently and optionally focuses an edge action. */
+  openMenu(e = "first") {
+    this.hasAttribute("data-overflow") && this._setProgrammaticOpen(!0, !1, e);
+  }
+  /** Closes the overflow popup silently. */
+  closeMenu(e = !1) {
+    this._setProgrammaticOpen(!1, e);
+  }
+  /** Toggles the overflow popup silently. */
+  toggleMenu(e = "first") {
+    !this.open && !this.hasAttribute("data-overflow") || this._setProgrammaticOpen(!this.open, this.open, e);
+  }
+  render() {
+    return x`
+      <div
+        id="root"
+        part="root"
+        role="toolbar"
+        aria-label=${this.label}
+        aria-orientation=${this.orientation}
+        ${d(this._onToolbarNavigate, {
+      navigationAxis: this.orientation
+    })}
+      >
+        <slot id="actions" @slotchange=${this._onSlotChange}></slot>
+        <span id="overflow-trigger-target">
+          <button
+            id="overflow-trigger"
+            part="overflow-trigger"
+            type="button"
+            aria-haspopup="menu"
+            aria-expanded="false"
+            aria-controls="popup"
+            aria-label=${this.overflowLabel}
+            title=${this.overflowLabel}
+            ${d(this._onTriggerNavigate, {
+      navigationAxis: this.orientation,
+      handleNavAxis: !1,
+      handleOpenAxis: !0,
+      handleEscape: this.open
+    })}
+            @click=${this._onTriggerClick}
+          >
+            <slot name="overflow-icon">
+              <svg id="overflow-icon" viewBox="0 0 24 24" aria-hidden="true">
+                <circle cx="12" cy="5" r="2"></circle>
+                <circle cx="12" cy="12" r="2"></circle>
+                <circle cx="12" cy="19" r="2"></circle>
+              </svg>
+            </slot>
+          </button>
+        </span>
+      </div>
+      <div
+        id="popup"
+        part="popup"
+        popover="manual"
+        role="menu"
+        aria-label=${this.overflowLabel}
+        ${d(this._onOverflowNavigate, {
+      navigationAxis: "vertical",
+      handleEscape: !0
+    })}
+        @click=${this._onPopupClick}
+      >
+        <slot id="overflow" name="overflow" @slotchange=${this._onSlotChange}></slot>
+      </div>
+    `;
+  }
+  static _ensureBaseStyles(e) {
+    if (s._styledRoots.has(e))
+      return;
+    s._styledRoots.add(e);
+    const t = (e instanceof Document ? e : e.ownerDocument).createElement("style");
+    t.setAttribute("data-rc-light-dom-base", "rc-adaptive-menu"), t.textContent = S, e instanceof Document ? e.head.append(t) : e.append(t);
+  }
+  _syncActions() {
+    const e = /* @__PURE__ */ new Set();
+    for (const t of Array.from(this.children)) {
+      if (!(t instanceof HTMLElement) || t.slot === "overflow-icon")
+        continue;
+      const r = this._authored.get(t), i = r?.slot ?? t.slot;
+      if (i && i !== "overflow")
+        continue;
+      const n = r?.focusTarget ?? this._focusTarget(t);
+      n && (e.add(t), r || this._authored.set(t, {
+        slot: i,
+        focusTarget: n,
+        orientation: t.getAttribute("orientation"),
+        role: n.getAttribute("role"),
+        tabindex: n.getAttribute("tabindex"),
+        forcedOverflow: i === "overflow"
+      }));
+    }
+    for (const [t, r] of this._authored)
+      e.has(t) || (this._restoreAction(t, r), this._authored.delete(t));
+    this._applySlots();
+  }
+  _entriesInDomOrder() {
+    return Array.from(this.children).flatMap((e) => {
+      if (!(e instanceof HTMLElement))
+        return [];
+      const t = this._authored.get(e);
+      return t ? [[e, t]] : [];
+    });
+  }
+  /**
+   * Assigns each authored action to the default (promoted) or overflow slot.
+   * A purely declarative computation from `max-shown`, `data-priority`, and
+   * authored `slot` — no size measurement of any kind.
+   */
+  _applySlots() {
+    const e = this._entriesInDomOrder(), t = (o) => {
+      const a = Number(o.dataset.priority ?? 0);
+      return Number.isFinite(a) ? a : 0;
+    }, r = ([o, a]) => a.forcedOverflow || t(o) < 0, i = e.filter((o) => !r(o)), n = i.map(([o], a) => ({
+      action: o,
+      index: a,
+      priority: t(o)
+    })).sort((o, a) => a.priority - o.priority || o.index - a.index), u = Number.isFinite(this.maxShown) ? Math.max(0, Math.trunc(this.maxShown)) : i.length, _ = Math.min(i.length, u), f = new Set(n.slice(0, _).map(({ action: o }) => o)), v = e.map(([o]) => o).filter((o) => !f.has(o)), m = e.find(
+      ([, o]) => o.focusTarget === this.ownerDocument.activeElement
+    )?.[0];
+    this.toggleAttribute("data-overflow", v.length > 0), m && v.includes(m) && this._$trigger.focus(), this._applyingSlots = !0;
+    for (const [o, a] of e)
+      f.has(o) ? (o.slot = "", o.setAttribute("data-rc-action-promoted", ""), o.removeAttribute("data-rc-action-overflowed"), this._restoreOrientation(o, a), this._restoreRole(a)) : (o.slot = "overflow", o.removeAttribute("data-rc-action-promoted"), o.setAttribute("data-rc-action-overflowed", ""), o.matches("rc-menu-button") && o.setAttribute("orientation", "vertical"), a.focusTarget.setAttribute("role", "menuitem"), a.focusTarget.setAttribute("tabindex", "-1"));
+    this._syncToolbarTabStops(), queueMicrotask(() => {
+      this._applyingSlots = !1;
+    }), this._syncOpenState();
+  }
+  _focusTarget(e) {
+    return e.matches(z) ? e.querySelector(
+      ':scope > button, :scope > a[href], :scope > [slot="trigger"]'
+    ) : e.matches("button, a[href]") ? e : null;
+  }
+  _promotedFocusTargets() {
+    const e = Array.from(this._authored.entries()).filter(([t]) => t.hasAttribute("data-rc-action-promoted")).map(([, t]) => t.focusTarget).filter((t) => g(t));
+    return this.hasAttribute("data-overflow") && e.push(this._$trigger), e;
+  }
+  _overflowFocusTargets() {
+    return Array.from(this._authored.entries()).filter(([e]) => e.hasAttribute("data-rc-action-overflowed")).map(([, e]) => e.focusTarget).filter((e) => g(e));
+  }
+  _syncToolbarTabStops(e) {
+    const t = this._promotedFocusTargets(), r = e && t.includes(e) ? e : t[0];
+    for (const i of t)
+      i.setAttribute("tabindex", i === r ? "0" : "-1");
+  }
+  _focusByNavigationAction(e, t) {
+    const r = this.ownerDocument.activeElement, i = r instanceof HTMLElement ? t.indexOf(r) : -1;
+    let n;
+    switch (e) {
+      case "next":
+        n = t[(i + 1) % t.length];
+        break;
+      case "prev":
+        n = t[(i - 1 + t.length) % t.length];
+        break;
+      case "start":
+        n = t[0];
+        break;
+      case "end":
+        n = t.at(-1);
+        break;
+    }
+    n?.focus();
+  }
+  _setProgrammaticOpen(e, t, r = "none") {
+    const i = this.open;
+    if (i === e) {
+      e && this._focusOverflowEdge(r);
+      return;
+    }
+    this._openInitialized ? this._open = e : this._uncontrolledOpen = e, this._restoreFocusWhenClosed = !e && t, this._focusWhenOpened = e ? r : null, this.requestUpdate("open", i), this._syncOpenState();
+  }
+  _requestUserOpen(e, t, r = "none") {
+    if (this.open !== e) {
+      if (this._restoreFocusWhenClosed = !e && t, this._focusWhenOpened = e ? r : null, this._open === void 0) {
+        const i = this.open;
+        this._uncontrolledOpen = e, this.requestUpdate("open", i), this._syncOpenState();
+      }
+      this.dispatchEvent(
+        new CustomEvent("rc-adaptive-menu-toggle", {
+          bubbles: !0,
+          composed: !0,
+          detail: { open: e }
+        })
+      );
+    }
+  }
+  _syncOpenState() {
+    const e = this._$popup;
+    if (e?.isConnected) {
+      if (this.open && this.hasAttribute("data-overflow")) {
+        let t = !1;
+        if (typeof e.showPopover == "function")
+          try {
+            e.showPopover(), t = !0;
+          } catch {
+          }
+        if (e.toggleAttribute("data-fallback-open", !t), this._$trigger.setAttribute("aria-expanded", "true"), this._anchor.update(), this._focusWhenOpened !== null) {
+          const r = this._focusWhenOpened;
+          this._focusWhenOpened = null, requestAnimationFrame(() => this._focusOverflowEdge(r));
+        }
+        return;
+      }
+      if (typeof e.hidePopover == "function")
+        try {
+          e.hidePopover();
+        } catch {
+        }
+      e.removeAttribute("data-fallback-open"), this._$trigger.setAttribute("aria-expanded", "false"), this._restoreFocusWhenClosed && (this._restoreFocusWhenClosed = !1, this._$trigger.focus());
+    }
+  }
+  _focusOverflowEdge(e) {
+    if (!this.open || e === "none")
+      return;
+    const t = this._overflowFocusTargets();
+    (e === "last" ? t.at(-1) : t[0])?.focus();
+  }
+  _restoreAction(e, t) {
+    e.slot = t.slot, e.removeAttribute("data-rc-action-promoted"), e.removeAttribute("data-rc-action-overflowed"), this._restoreOrientation(e, t), this._restoreRole(t), t.tabindex === null ? t.focusTarget.removeAttribute("tabindex") : t.focusTarget.setAttribute("tabindex", t.tabindex);
+  }
+  _restoreOrientation(e, t) {
+    e.matches("rc-menu-button") && (t.orientation === null ? e.removeAttribute("orientation") : e.setAttribute("orientation", t.orientation));
+  }
+  _restoreRole(e) {
+    e.role === null ? e.focusTarget.removeAttribute("role") : e.focusTarget.setAttribute("role", e.role);
+  }
+  _isDisabled(e) {
+    return e instanceof HTMLButtonElement && e.disabled || e.getAttribute("aria-disabled") === "true";
+  }
+}, s.styles = A, s._styledRoots = /* @__PURE__ */ new WeakSet(), s);
+c([
+  p({ type: String })
+], l.prototype, "label", 2);
+c([
+  p({ type: Number, attribute: "max-shown" })
+], l.prototype, "maxShown", 2);
+c([
+  p({ type: Boolean, reflect: !0 })
+], l.prototype, "open", 1);
+c([
+  p({ type: Boolean, attribute: "default-open" })
+], l.prototype, "defaultOpen", 1);
+c([
+  p({ type: String, reflect: !0 })
+], l.prototype, "orientation", 2);
+c([
+  p({ type: String, attribute: "overflow-label" })
+], l.prototype, "overflowLabel", 2);
+c([
+  b("#overflow-trigger")
+], l.prototype, "_$trigger", 2);
+c([
+  b("#popup")
+], l.prototype, "_$popup", 2);
+let E = l;
+export {
+  E as R
+};
+//# sourceMappingURL=rc-adaptive-menu-BwvfkD_X.js.map