@kerfjs/ui 5.0.0-beta.8 → 5.0.0-beta.80

package/dist/nav-stack-B1Qc2e5q.d.ts

@@ -0,0 +1,101 @@
+import * as kerfjs from 'kerfjs';
+import { K as KerfUiContent } from './semantic-content-BbzjvSu9.js';
+import { ListConfig } from './list.js';
+import { PaneConfig } from './pane.js';
+import { c as PanelBottomToolbar } from './panel-toolbar-CL9tYOkh.js';
+import { ToolbarConfig } from './toolbar.js';
+import { ToolbarTextSize, HeadingLevel } from './toolbar-text.js';
+
+/** Content and chrome shared by a navigation view and a static workbench panel. */
+interface NavPane<TToolbar, TBottomToolbar> {
+    content: KerfUiContent;
+    toolbar?: TToolbar;
+    header?: KerfUiContent;
+    headerList?: ListConfig;
+    footer?: KerfUiContent;
+    footerList?: ListConfig;
+    bottomToolbar?: TBottomToolbar;
+    pane?: PaneConfig;
+}
+
+/**
+ * One entry in a {@link NavStack}. The app owns the stack as an array (usually a
+ * signal); `NavStack` renders it and `wireNavStack` animates the transitions.
+ */
+interface NavStackView extends NavPane<NavStackViewToolbar, PanelBottomToolbar> {
+    /** Stable identity for keyed reconcile and transition direction. */
+    key: string;
+}
+/** Per-view top toolbar. The stack supplies its back control before `leading`. */
+interface NavStackViewToolbar extends NavStackToolbarConfig {
+    title?: string;
+    leading?: KerfUiContent;
+    center?: KerfUiContent;
+    trailing?: KerfUiContent;
+}
+/** A view's structured bottom toolbar; it cross-fades on navigation. */
+type NavStackViewBottomToolbar = PanelBottomToolbar;
+/**
+ * The top toolbar's configuration. Its `ToolbarConfig` forwards to the real
+ * `Toolbar` the stack renders; by default that toolbar draws no divider and
+ * claims the top and side safe-area edges the stack still touches.
+ */
+interface NavStackToolbarConfig extends ToolbarConfig {
+    /** Accessible name of the top toolbar (default: none). */
+    label?: string;
+    /** Size of the view title's `ToolbarText` (default `large`). */
+    titleSize?: ToolbarTextSize;
+    /** Expose the view title as a heading at this level (default: a plain span). */
+    headingLevel?: HeadingLevel;
+}
+interface NavStackProps {
+    id: string;
+    /** Accessible name for the stack region. */
+    label: string;
+    /** The stack, root first; the last entry is the active top view. */
+    views: NavStackView[];
+    /** Accessible label for the icon-only back control (default "Back"). */
+    backLabel?: string;
+    /** The back control's icon (default a chevron-left `LucideIcon`). */
+    backIcon?: KerfUiContent;
+    /**
+     * Visible text beside the back icon, such as the previous view's title
+     * (default: icon only). When set, the text names the control and
+     * `backLabel` is not used.
+     */
+    backText?: string;
+    /** The top toolbar's configuration, forwarded to its `Toolbar`. */
+    toolbarConfig?: NavStackToolbarConfig;
+    /** Persistent last group in every view's top toolbar, supplied by a hosting panel. */
+    panelToggle?: KerfUiContent;
+    /** Hide the top toolbar entirely (rare — a fully custom-chrome view). */
+    hideToolbar?: boolean;
+    /** Optional persistent bottom toolbar used when the active view does not provide one. */
+    bottomToolbar?: NavStackViewBottomToolbar;
+    /**
+     * The line under the top chrome and over the bottom toolbar, where they
+     * meet the active view. `scroll` (default) shows the chrome's line only
+     * while the view's content is scrolled beneath it, and the bottom
+     * toolbar's only while more content lies below — never when the content
+     * fits — once `wireScrollDividers` (`@kerfjs/ui/wire-scroll-dividers`) is
+     * wired above the stack; unwired, neither shows. `always` shows both
+     * without the wiring; `none` neither, even when wired. The line is drawn
+     * inside the chrome, so no state moves the chrome or the content. A
+     * `toolbarConfig.dividerSides` edge is the Toolbar's own and is unaffected.
+     */
+    chromeDividers?: 'scroll' | 'always' | 'none';
+    className?: string;
+    /** Native named-slot assignment when composed inside a web component. */
+    slot?: string;
+}
+/**
+ * A navigation stack (iOS-style push/pop). Renders every entry stacked, the last
+ * one active; `@kerfjs/ui/wire-nav-stack`'s `wireNavStack` slides the content and
+ * cross-fades the chrome across a change. Its top chrome is a real `Toolbar`: the
+ * back control and title lead, the active view's `toolbar` fills the zones,
+ * and `toolbarConfig` supplies defaults. A single-pane
+ * layout is a `NavStack` with one entry. See `docs/23-app-layouts.md` §3.1.
+ */
+declare function NavStack({ id, label, views, backLabel, backIcon, backText, toolbarConfig, panelToggle, hideToolbar, bottomToolbar, chromeDividers, className, slot, }: NavStackProps): kerfjs.SafeHtml;
+
+export { type NavStackProps as N, type NavStackView as a, type NavPane as b, NavStack as c, type NavStackToolbarConfig as d, type NavStackViewBottomToolbar as e, type NavStackViewToolbar as f };

package/dist/nav-stack.d.ts

@@ -1,38 +1,13 @@
-import { SafeHtml } from 'kerfjs';
-
-/**
- * One entry in a {@link NavStack}. The app owns the stack as an array (usually a
- * signal); `NavStack` renders it and `wireNavStack` animates the transitions.
- */
-interface NavStackView {
-    /** Stable identity for keyed reconcile and transition direction. */
-    key: string;
-    content: SafeHtml;
-    /** Title shown in the top toolbar for this view. */
-    title?: string;
-    /** Trailing actions for this view's top toolbar. */
-    toolbar?: SafeHtml;
-}
-interface NavStackProps {
-    id: string;
-    /** Accessible name for the stack region. */
-    label: string;
-    /** The stack, root first; the last entry is the active top view. */
-    views: NavStackView[];
-    /** Accessible label for the back control (default "Back"). */
-    backLabel?: string;
-    /** Hide the top toolbar entirely (rare — a fully custom-chrome view). */
-    hideToolbar?: boolean;
-    /** Optional persistent bottom toolbar. */
-    bottomToolbar?: SafeHtml;
-    className?: string;
-}
-/**
- * A navigation stack (iOS-style push/pop). Renders every entry stacked, the last
- * one active; `@kerfjs/ui/wire-nav-stack`'s `wireNavStack` slides the content and
- * cross-fades the chrome across a change. A single-pane layout is a `NavStack`
- * with one entry. See `docs/23-app-layouts.md` §3.1.
- */
-declare function NavStack({ id, label, views, backLabel, hideToolbar, bottomToolbar, className }: NavStackProps): SafeHtml;
-
-export { NavStack, type NavStackProps, type NavStackView };
+export { c as NavStack, N as NavStackProps, d as NavStackToolbarConfig, a as NavStackView, e as NavStackViewBottomToolbar, f as NavStackViewToolbar } from './nav-stack-B1Qc2e5q.js';
+import 'kerfjs';
+import './semantic-content-BbzjvSu9.js';
+import './list.js';
+import './flex-alignment-4ms8ZbV8.js';
+import './sides-BPSWde0A.js';
+import './css-values.js';
+import './pane.js';
+import './panel-toolbar-CL9tYOkh.js';
+import './toolbar.js';
+import './lucide-icon.js';
+import 'lucide';
+import './toolbar-text.js';

package/dist/nav-stack.js

@@ -1,4 +1,13 @@
-export { NavStack } from './chunk-BLK3UEEI.js';
+export { NavStack } from './chunk-CVKIADIS.js';
+
+
+
+
+
+
+
+
+
 
 
 

package/dist/pane.d.ts

@@ -0,0 +1,116 @@
+import * as kerfjs from 'kerfjs';
+import { K as KerfUiContent } from './semantic-content-BbzjvSu9.js';
+
+/**
+ * Logical pane sides: where a {@link Pane} can show a separator and where it can
+ * compensate for a device safe-area inset.
+ */
+type PaneSeparatorSide = 'block-start' | 'block-end' | 'inline-start' | 'inline-end';
+/** Semantic root elements supported by {@link Pane}. */
+type PaneElement = 'article' | 'aside' | 'div' | 'main' | 'section';
+/** Semantic elements supported by the scrolling content slot. */
+type PaneContentElement = 'div' | 'main' | 'nav' | 'section';
+type PaneRootAttributes = Readonly<Record<`data-${string}`, string | undefined> & {
+    'data-component'?: never;
+    'data-separator-block-start'?: never;
+    'data-separator-block-end'?: never;
+    'data-separator-inline-start'?: never;
+    'data-separator-inline-end'?: never;
+    'data-safe-area-block-start'?: never;
+    'data-safe-area-block-end'?: never;
+    'data-safe-area-inline-start'?: never;
+    'data-safe-area-inline-end'?: never;
+    'data-chrome-placement'?: never;
+    'data-chrome-dividers'?: never;
+    'data-appearance'?: never;
+    'data-deep-inset'?: never;
+    'data-outlined'?: never;
+}>;
+/** How a Pane's header and footer relate to its scrolling content. */
+type PaneChromePlacement = 'fixed' | 'auto';
+/**
+ * When a Pane draws the divider between its pinned header or footer and its
+ * scrolling content: `scroll` while content is scrolled away beneath that
+ * chrome, as `wireScrollDividers` reports; `always`; or `none`.
+ */
+type PaneChromeDividers = 'scroll' | 'always' | 'none';
+/** Background treatment of the Pane's scrolling work surface. */
+type PaneAppearance = 'default' | 'sunken';
+interface PaneProps {
+    /** Optional fixed chrome above the scrolling content, arranged vertically. */
+    header?: KerfUiContent;
+    /** The pane's primary vertical, scrolling content stack. */
+    children?: KerfUiContent;
+    /** Optional fixed chrome below the scrolling content. */
+    footer?: KerfUiContent;
+    /**
+     * Whether the header and footer stay pinned around the scrolling content.
+     * `fixed` (default) always pins them. `auto` pins them while the pane is
+     * tall enough, and below 480px of height (30rem, so it scales with the text
+     * size) lets the whole pane scroll as one column, so tall chrome can never
+     * squeeze the content to nothing.
+     */
+    chromePlacement?: PaneChromePlacement;
+    /**
+     * The divider under the header and over the footer, where they meet the
+     * scrolling content. Omitted defaults to `scroll` for a plain pane and
+     * `always` for `appearance="sunken"`. `scroll` shows the header's divider only
+     * while the content is scrolled down, and the footer's only while more
+     * content lies below — never when the content fits — once
+     * `wireScrollDividers` (`@kerfjs/ui/wire-scroll-dividers`) is wired above
+     * the pane; unwired, neither shows. `always` shows both; `none` neither.
+     * The line is drawn inside the chrome, so no state moves the content.
+     */
+    chromeDividers?: PaneChromeDividers;
+    /** Paint the scrolling work surface with the shared lowered-surface color. */
+    appearance?: PaneAppearance;
+    /** Add 8px to every side of scrolling content (default: false). */
+    deepInset?: boolean;
+    /** Opt into keyboard (`0`) or programmatic (`-1`) focus on the Pane root. */
+    tabIndex?: 0 | -1;
+    /** Keep the standard focus outline visible, such as for a drop target. */
+    outlined?: boolean;
+    /** Root semantics. Defaults to `div`. */
+    element?: PaneElement;
+    /** Scrolling content semantics. Defaults to `div`. */
+    contentElement?: PaneContentElement;
+    /** Independent logical-edge separator lines. Defaults to none. */
+    separators?: readonly PaneSeparatorSide[];
+    /**
+     * Sides on which the pane may compensate for a device safe-area inset.
+     * Defaults to every side: the pane pads its slots for each side that still
+     * reaches an unsafe screen edge, as its surrounding layout reports, while its
+     * background and separators paint through. List only the sides an app-owned
+     * layout places at a screen edge, or pass `[]` to opt out.
+     */
+    safeAreaEdges?: readonly PaneSeparatorSide[];
+    id?: string;
+    /** Accessible name for a landmark root such as `aside` or `main`. */
+    label?: string;
+    /** Accessible name for a landmark scrolling slot such as `nav`. */
+    contentLabel?: string;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+    /** Safe `data-*` metadata; Pane-owned structural attributes remain protected. */
+    rootAttributes?: PaneRootAttributes;
+    /** Native named-slot assignment when composed inside a web component. */
+    slot?: string;
+}
+/**
+ * A pane's configuration, apart from its content and styling hooks: the props a
+ * composite that renders a `Pane` for the app (a Workbench panel or work area,
+ * or a CollapsiblePanel) forwards, so the app configures that pane instead of
+ * styling it. An omitted or `undefined` field keeps the composite's default.
+ */
+type PaneConfig = Pick<PaneProps, 'contentElement' | 'contentLabel' | 'separators' | 'safeAreaEdges' | 'chromeDividers' | 'appearance' | 'deepInset' | 'tabIndex' | 'outlined'>;
+/**
+ * An unpadded application column with optional fixed header/footer slots and one
+ * scrolling vertical content owner. Separator lines are independently opt-in on
+ * each logical edge, so the same component works as a sidebar, main area,
+ * inspector, or dialog column.
+ */
+declare function Pane({ header, children, footer, chromePlacement, chromeDividers, appearance, deepInset, tabIndex, outlined, element, contentElement, separators, safeAreaEdges, id, label, contentLabel, className, headerClassName, contentClassName, footerClassName, rootAttributes, slot, }: PaneProps): kerfjs.SafeHtml;
+
+export { Pane, type PaneAppearance, type PaneChromeDividers, type PaneChromePlacement, type PaneConfig, type PaneContentElement, type PaneElement, type PaneProps, type PaneSeparatorSide };

package/dist/pane.js

@@ -0,0 +1,4 @@
+export { Pane } from './chunk-FL6J644M.js';
+
+
+//# sourceMappingURL=pane.js.map

package/dist/pane.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"pane.js"}

package/dist/panel-toolbar-CL9tYOkh.d.ts

@@ -0,0 +1,72 @@
+import { ToolbarConfig } from './toolbar.js';
+import { K as KerfUiContent } from './semantic-content-BbzjvSu9.js';
+import { LucideIcon } from './lucide-icon.js';
+
+/** Which edge a collapsible panel docks to. */
+type PanelSide = 'left' | 'right' | 'bottom';
+/**
+ * The standard collapse/expand icon for a panel `side` and `collapsed` state,
+ * so every app's sidebars and drawers use one recognizable convention:
+ * `PanelLeft*` for a left rail, `PanelRight*` for a right rail, `PanelBottom*`
+ * for a bottom drawer — the `Close` glyph while open, the `Open` glyph while
+ * collapsed. Exposed so an app can render its own toggle affordance.
+ */
+declare function collapsiblePanelToggleIcon(side: PanelSide, collapsed: boolean): {
+    icon: Parameters<typeof LucideIcon>[0]['icon'];
+    name: string;
+};
+/**
+ * The standard collapse toggle a panel toolbar renders. The app handles the
+ * button's `data-action` and flips its own `collapsed` flag.
+ */
+interface PanelToggle {
+    /** The `data-action` the toggle button carries. */
+    action: string;
+    /** The panel's short name, for the accessible "Show …" / "Hide …" label. */
+    name: string;
+    /** Accessible label while the panel is collapsed. Defaults to `Show {name}`. */
+    showLabel?: string;
+    /** Accessible label while the panel is open. Defaults to `Hide {name}`. */
+    hideLabel?: string;
+}
+/**
+ * A collapsible panel's top toolbar, composed so its groups follow the
+ * panel's open state.
+ *
+ * - `title` precedes the `leading` zone. Groups may appear in any of the
+ *   `leading`, `center`, and `trailing` zones while the panel is open.
+ * - Groups marked `relocateOnCollapse` move to the work area's toolbar while
+ *   the panel is collapsed, preserving their order across the three zones.
+ * - `toggle` is always the last group: in the panel's toolbar while it is
+ *   open, and right after the relocated groups in the work area's toolbar
+ *   while it is collapsed.
+ *
+ * Relocated content renders in both places while the panel is collapsed (the
+ * panel's copy is inert), so give it no `id`s. Pass groups directly or in
+ * arrays so their render-time annotation remains available to the panel.
+ *
+ * The toolbar's configuration (`dividerSides`, `centerAlign`, `responsive`,
+ * `responsiveAt`, `safeAreaEdges`) forwards to its `Toolbar`. It draws no
+ * divider of its own: the panel's `Pane` draws the line under it while the
+ * content is scrolled (its `chromeDividers`, wired by `wireScrollDividers`).
+ */
+interface PanelToolbar extends ToolbarConfig {
+    /** Accessible name of the panel's toolbar. */
+    label: string;
+    title?: KerfUiContent;
+    leading?: KerfUiContent;
+    center?: KerfUiContent;
+    trailing?: KerfUiContent;
+    toggle?: PanelToggle;
+}
+/** A panel's fixed bottom toolbar, below its optional footer content. */
+interface PanelBottomToolbar extends ToolbarConfig {
+    label: string;
+    leading?: KerfUiContent;
+    center?: KerfUiContent;
+    trailing?: KerfUiContent;
+}
+/** Whether panel chrome stays fixed, scrolls, or follows Pane's auto rule. */
+type PanelChromePlacement = 'fixed' | 'scroll' | 'auto';
+
+export { type PanelSide as P, type PanelToolbar as a, type PanelChromePlacement as b, type PanelBottomToolbar as c, type PanelToggle as d, collapsiblePanelToggleIcon as e };

package/dist/popup-menu-register.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Marker export for tests and tooling; importing this module registers the
+ * Web Awesome elements a `PopupMenu` renders (`wa-dropdown`,
+ * `wa-dropdown-item`, `wa-button`, and `wa-divider`) and routes a keyboard
+ * choice through the item's click so delegated `data-action`s run.
+ */
+declare const popupMenuElementsRegistered = true;
+
+export { popupMenuElementsRegistered };

package/dist/popup-menu-register.js

@@ -0,0 +1,244 @@
+import { installHelpTags } from './chunk-O27D24CA.js';
+import '@awesome.me/webawesome/dist/components/button/button.js';
+import '@awesome.me/webawesome/dist/components/divider/divider.js';
+import WaDropdownItem from '@awesome.me/webawesome/dist/components/dropdown-item/dropdown-item.js';
+import '@awesome.me/webawesome/dist/components/tooltip/tooltip.js';
+import WaDropdown from '@awesome.me/webawesome/dist/components/dropdown/dropdown.js';
+
+// src/components/actions/popup-menu/internal/install-dropdown-show-focus.ts
+var installed = /* @__PURE__ */ new WeakSet();
+var showEpoch = /* @__PURE__ */ new WeakMap();
+function installDropdownShowFocus(prototype) {
+  if (installed.has(prototype)) return;
+  installed.add(prototype);
+  const target = prototype;
+  const showMenu = target.showMenu;
+  target.showMenu = async function() {
+    const scoped = this.classList.contains("kui-popup-menu") || this.closest(".kui-popup-surface") !== null;
+    if (!scoped) return showMenu.call(this);
+    const epoch = (showEpoch.get(this) ?? 0) + 1;
+    showEpoch.set(this, epoch);
+    let navigatedItem;
+    const rememberFocus = (event) => {
+      const item = event.target;
+      if (this.menu?.classList.contains("show") && item instanceof HTMLElement && item.localName === "wa-dropdown-item" && this.contains(item)) {
+        navigatedItem = item;
+      }
+    };
+    this.addEventListener("focusin", rememberFocus);
+    try {
+      await showMenu.call(this);
+    } finally {
+      this.removeEventListener("focusin", rememberFocus);
+    }
+    if (showEpoch.get(this) !== epoch || !this.open || !this.popup?.active || !navigatedItem?.isConnected || !this.contains(navigatedItem))
+      return;
+    const siblings = navigatedItem.slot === "submenu" ? Array.from(navigatedItem.parentElement?.children ?? []).filter(
+      (item) => item.localName === "wa-dropdown-item"
+    ) : this.getItems();
+    siblings.forEach((item) => {
+      item.active = item === navigatedItem;
+    });
+    navigatedItem.focus({ preventScroll: true });
+  };
+}
+
+// src/components/actions/popup-menu/internal/install-popup-menu-keyboard.ts
+var installed2 = /* @__PURE__ */ new WeakSet();
+function installPopupMenuKeyboard(prototype) {
+  if (installed2.has(prototype)) return;
+  installed2.add(prototype);
+  const target = prototype;
+  const makeSelection = target.makeSelection;
+  target.makeSelection = function(item, event) {
+    if (event instanceof KeyboardEvent && this.classList.contains("kui-popup-menu") && !item.disabled) {
+      item.click();
+      return;
+    }
+    makeSelection.call(this, item, event);
+  };
+}
+
+// src/components/actions/popup-menu/internal/install-popup-menu-lifecycle.ts
+var installed3 = /* @__PURE__ */ new WeakSet();
+function installPopupMenuLifecycle(prototype) {
+  if (installed3.has(prototype)) return;
+  installed3.add(prototype);
+  const target = prototype;
+  const showMenu = target.showMenu;
+  const hideMenu = target.hideMenu;
+  const hiding = /* @__PURE__ */ new WeakMap();
+  target.showMenu = function() {
+    const transition = hiding.get(this);
+    if (transition && this.open && this.popup?.active && this.classList.contains("kui-popup-menu")) {
+      this.popup.active = false;
+      transition.reopened = true;
+    }
+    return showMenu.call(this);
+  };
+  target.hideMenu = async function() {
+    const scoped = this.classList.contains("kui-popup-menu");
+    const transition = { reopened: false };
+    if (scoped) hiding.set(this, transition);
+    await hideMenu.call(this);
+    if (scoped && hiding.get(this) === transition && this.open && this.isConnected && this.popup?.active && !transition.reopened) {
+      this.popup.active = false;
+      void this.showMenu();
+    }
+    if (hiding.get(this) === transition) hiding.delete(this);
+  };
+}
+
+// src/components/actions/popup-menu/internal/install-popup-menu-submenu-focus.ts
+var installed4 = /* @__PURE__ */ new WeakSet();
+function installPopupMenuSubmenuFocus(prototype) {
+  if (installed4.has(prototype)) return;
+  installed4.add(prototype);
+  const target = prototype;
+  const openSubmenu = target.openSubmenu;
+  const closeSubmenu = target.closeSubmenu;
+  const submenuOpen = Object.getOwnPropertyDescriptor(prototype, "submenuOpen");
+  if (submenuOpen?.set) {
+    Object.defineProperty(prototype, "submenuOpen", {
+      ...submenuOpen,
+      set(value) {
+        const wasOpen = this.submenuOpen;
+        submenuOpen.set.call(this, value);
+        if (value && wasOpen && this.submenuElement?.hidden && this.closest("wa-dropdown.kui-popup-menu"))
+          void this.openSubmenu();
+      }
+    });
+  }
+  target.closeSubmenu = async function() {
+    const submenu = this.submenuElement;
+    await closeSubmenu.call(this);
+    if (this.submenuOpen && submenu?.hidden && this.isConnected && this.closest("wa-dropdown.kui-popup-menu"))
+      void this.openSubmenu();
+  };
+  target.openSubmenu = async function() {
+    const submenu = this.submenuElement;
+    if (!this.closest("wa-dropdown.kui-popup-menu") || !submenu)
+      return openSubmenu.call(this);
+    if (submenu.classList.contains("show")) {
+      if (!submenu.hidden) return;
+      submenu.classList.remove("show");
+    }
+    let desired;
+    const trackFocus = (event) => {
+      const item = event.composedPath().find(
+        (node) => node instanceof HTMLElement && node.localName === "wa-dropdown-item" && node.getAttribute("slot") === "submenu"
+      );
+      if (item && this.getSubmenuItems().includes(item)) desired = item;
+    };
+    submenu.addEventListener("focusin", trackFocus);
+    try {
+      await openSubmenu.call(this);
+    } finally {
+      submenu.removeEventListener("focusin", trackFocus);
+    }
+    const items = this.getSubmenuItems();
+    if (!desired || desired === items[0]) return;
+    const selected = desired;
+    window.setTimeout(() => {
+      if (!this.isConnected || !this.submenuOpen || submenu.hidden || document.activeElement !== items[0])
+        return;
+      items.forEach((item) => item.active = item === selected);
+      selected.focus({ preventScroll: true });
+    }, 0);
+  };
+}
+
+// src/components/actions/popup-menu/internal/install-popup-menu-submenu-placement.ts
+var installed5 = /* @__PURE__ */ new WeakSet();
+var phoneWidth = "(max-width: 480px)";
+var viewportInset = 8;
+var menuGap = 4;
+function phoneSubmenuPosition(parent, submenu, viewport, rtl) {
+  const width = Math.min(submenu.width, viewport.width - 2 * viewportInset);
+  const height = submenu.height;
+  const below = Math.max(
+    0,
+    viewport.height - parent.bottom - menuGap - viewportInset
+  );
+  const above = Math.max(0, parent.top - menuGap - viewportInset);
+  const useBelow = height <= below || height > above && below >= above;
+  const availableHeight = useBelow ? below : above;
+  const left = rtl ? parent.right - width : parent.left;
+  return {
+    left: Math.max(
+      viewportInset,
+      Math.min(left, viewport.width - viewportInset - width)
+    ),
+    top: useBelow ? parent.bottom + menuGap : parent.top - menuGap - Math.min(height, availableHeight),
+    maxHeight: availableHeight,
+    maxWidth: viewport.width - 2 * viewportInset
+  };
+}
+function clearPhoneStyles(submenu) {
+  for (const property of [
+    "position",
+    "left",
+    "top",
+    "max-width",
+    "max-height",
+    "box-sizing",
+    "overflow-y"
+  ])
+    submenu.style.removeProperty(property);
+}
+function installPopupMenuSubmenuPlacement(prototype) {
+  if (installed5.has(prototype)) return;
+  installed5.add(prototype);
+  const target = prototype;
+  const positionSubmenu = target.positionSubmenu;
+  target.positionSubmenu = function(item) {
+    if (!this.classList.contains("kui-popup-menu")) {
+      positionSubmenu.call(this, item);
+      return;
+    }
+    const submenu = item.submenuElement;
+    if (!window.matchMedia(phoneWidth).matches || !submenu || !this.menu) {
+      if (submenu) clearPhoneStyles(submenu);
+      positionSubmenu.call(this, item);
+      return;
+    }
+    window.queueMicrotask(() => {
+      if (!this.isConnected || !item.submenuOpen || !window.matchMedia(phoneWidth).matches || !this.menu || !submenu.isConnected)
+        return;
+      const parentItem = item.parentElement?.localName === "wa-dropdown-item" ? item.parentElement : void 0;
+      const parentMenu = parentItem?.submenuElement ?? this.menu;
+      submenu.style.position = "fixed";
+      submenu.style.maxWidth = `calc(100vw - ${2 * viewportInset}px)`;
+      submenu.style.maxHeight = "none";
+      submenu.style.boxSizing = "border-box";
+      submenu.style.overflowY = "auto";
+      const placement = phoneSubmenuPosition(
+        parentMenu.getBoundingClientRect(),
+        submenu.getBoundingClientRect(),
+        { width: window.innerWidth, height: window.innerHeight },
+        window.getComputedStyle(this).direction === "rtl"
+      );
+      submenu.style.left = `${placement.left}px`;
+      submenu.style.top = `${placement.top}px`;
+      submenu.style.maxHeight = `${placement.maxHeight}px`;
+      submenu.style.maxWidth = `${placement.maxWidth}px`;
+      submenu.setAttribute(
+        "data-placement",
+        placement.top >= parentMenu.getBoundingClientRect().bottom ? "bottom-start" : "top-start"
+      );
+    });
+  };
+}
+
+// src/components/actions/popup-menu/register/popup-menu-register.ts
+installPopupMenuKeyboard(WaDropdown.prototype);
+installPopupMenuLifecycle(WaDropdown.prototype);
+installDropdownShowFocus(WaDropdown.prototype);
+installPopupMenuSubmenuFocus(WaDropdownItem.prototype);
+installPopupMenuSubmenuPlacement(WaDropdown.prototype);
+installHelpTags();
+var popupMenuElementsRegistered = true;
+
+export { popupMenuElementsRegistered };
+
+//# sourceMappingURL=popup-menu-register.js.map