@swisspost/design-system-components 10.0.0-next.46 → 10.0.0-next.48

package/dist/components/post-menu-trigger2.js

@@ -0,0 +1,110 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { v as version } from './package.js';
+import { c as checkRequiredAndType } from './index2.js';
+import './breakpoints.js';
+import { g as getRoot } from './get-root.js';
+
+const postMenuTriggerCss = ":host{display:inline-block}";
+
+const PostMenuTrigger = /*@__PURE__*/ proxyCustomElement(class PostMenuTrigger extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        /**
+         * Manages the accessibility attribute `aria-expanded` to indicate whether the associated menu is expanded or collapsed.
+         */
+        this.ariaExpanded = false;
+        /**
+         * Reference to the slotted button within the trigger, if present.
+         * Used to manage click and key events for menu control.
+         */
+        this.slottedButton = null;
+        this.handleKeyDown = (e) => {
+            if (e.key === 'ArrowUp' || e.key === 'ArrowDown') {
+                e.preventDefault();
+                this.handleToggle();
+            }
+        };
+    }
+    /**
+     * Watch for changes to the `for` property to validate its type and ensure it is a string.
+     * @param forValue - The new value of the `for` property.
+     */
+    validateControlFor() {
+        checkRequiredAndType(this, 'for', 'string');
+    }
+    get menu() {
+        const ref = this.root.getElementById(this.for);
+        return ref && ref.localName === 'post-menu' ? ref : null;
+    }
+    handleToggle() {
+        if (this.menu) {
+            this.menu.toggle(this.host);
+        }
+        else {
+            console.warn(`No post-menu found with ID: ${this.for}`);
+        }
+    }
+    connectedCallback() {
+        this.root = getRoot(this.host);
+    }
+    componentDidLoad() {
+        this.validateControlFor();
+        this.slottedButton = this.host.querySelector('button');
+        // Check if the slottedButton is within a web component
+        if (!this.slottedButton) {
+            const webComponent = this.host.querySelector('.menu-trigger-webc');
+            if (webComponent?.shadowRoot) {
+                const slottedButton = webComponent.shadowRoot.querySelector('button');
+                if (slottedButton) {
+                    this.slottedButton = slottedButton;
+                }
+            }
+        }
+        if (this.slottedButton) {
+            this.slottedButton.setAttribute('aria-haspopup', 'menu');
+            // Listen to the `toggleMenu` event emitted by the `post-menu` component
+            if (this.menu && this.slottedButton) {
+                this.menu.addEventListener('toggleMenu', (event) => {
+                    this.ariaExpanded = event.detail;
+                    this.slottedButton.setAttribute('aria-expanded', this.ariaExpanded.toString());
+                });
+            }
+            this.slottedButton.addEventListener('click', () => {
+                this.handleToggle();
+            });
+            this.slottedButton.addEventListener('keydown', this.handleKeyDown);
+        }
+        else {
+            console.warn('No button found within post-menu-trigger');
+        }
+    }
+    render() {
+        return (h(Host, { key: '76b3c59cdae5c78cefaaf1ea2a9668a77bddd37e', "data-version": version, "tab-index": "-1" }, h("slot", { key: '3835d87c3795e694f7493ceb735bd638bdd2dea1' })));
+    }
+    get host() { return this; }
+    static get watchers() { return {
+        "for": ["validateControlFor"]
+    }; }
+    static get style() { return postMenuTriggerCss; }
+}, [4, "post-menu-trigger", {
+        "for": [513],
+        "ariaExpanded": [32]
+    }, undefined, {
+        "for": ["validateControlFor"]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["post-menu-trigger"];
+    components.forEach(tagName => { switch (tagName) {
+        case "post-menu-trigger":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, PostMenuTrigger);
+            }
+            break;
+    } });
+}
+
+export { PostMenuTrigger as P, defineCustomElement as d };

package/dist/components/post-menu.js

@@ -1,4 +1,4 @@
-import { P as PostMenu$1, d as defineCustomElement$1 } from './p-C1i4rB_c.js';
+import { P as PostMenu$1, d as defineCustomElement$1 } from './post-menu2.js';
 
 const PostMenu = PostMenu$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/post-menu2.js

@@ -0,0 +1,222 @@
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { a as PLACEMENT_TYPES, d as defineCustomElement$1 } from './post-popovercontainer2.js';
+import { v as version } from './package.js';
+import { g as getFocusableChildren } from './get-focusable-children.js';
+import { d as checkEmptyOrOneOf } from './index2.js';
+import './breakpoints.js';
+import { E as EventFrom } from './event-from.js';
+import { g as getRoot } from './get-root.js';
+
+const postMenuCss = "@keyframes popIn{from{transform:scale(0.9);opacity:0;transition-property:transform,opacity,overlay,display;transition-behavior:allow-discrete;transition-duration:var(--post-transition-duration, 0.35s);transition-timing-function:linear(0, 0.007, 0.029 2.2%, 0.118 4.7%, 0.625 14.4%, 0.826 19%, 0.902, 0.962, 1.008 26.1%, 1.041 28.7%, 1.064 32.1%, 1.07 36%, 1.061 40.5%, 1.015 53.4%, 0.999 61.6%, 0.995 71.2%, 1)}to{opacity:1;transform:scale(1)}}:host{display:block}:where([part=menu]){display:flex;flex-direction:column;padding-block:.5rem}";
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+const PostMenu = /*@__PURE__*/ proxyCustomElement(class PostMenu extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        this.toggleMenu = createEvent(this, "toggleMenu", 7);
+        this.lastFocusedElement = null;
+        this.KEYCODES = {
+            SPACE: ' ',
+            ENTER: 'Enter',
+            UP: 'ArrowUp',
+            DOWN: 'ArrowDown',
+            TAB: 'Tab',
+            HOME: 'Home',
+            END: 'End',
+            ESCAPE: 'Escape',
+        };
+        /**
+         * Defines the position of the menu relative to its trigger.
+         * Menus are automatically flipped to the opposite side if there is not enough available space and are shifted towards the viewport if they would overlap edge boundaries.
+         * For supported values and behavior details, see the [Floating UI placement documentation](https://floating-ui.com/docs/computePosition#placement).
+         */
+        this.placement = 'bottom';
+        /**
+         * Holds the current visibility state of the menu.
+         * This state is internally managed to track whether the menu is open (`true`) or closed (`false`),
+         * and updates automatically when the menu is toggled.
+         */
+        this.isVisible = false;
+        this.handleKeyDown = (e) => {
+            e.stopPropagation();
+            if (e.key === this.KEYCODES.ESCAPE) {
+                this.toggle(this.host);
+                return;
+            }
+            if (Object.values(this.KEYCODES).includes(e.key)) {
+                this.controlKeyDownHandler(e);
+            }
+        };
+        this.handlePostToggle = (event) => {
+            this.isVisible = event.detail;
+            this.toggleMenu.emit(this.isVisible);
+            requestAnimationFrame(() => {
+                if (this.isVisible) {
+                    this.lastFocusedElement = this.root?.activeElement;
+                    const menuItems = this.getSlottedItems();
+                    if (menuItems.length > 0) {
+                        menuItems[0].focus();
+                    }
+                }
+                else if (this.lastFocusedElement) {
+                    this.lastFocusedElement.focus();
+                }
+            });
+        };
+        this.handleClick = (e) => {
+            const target = e.target;
+            if (['BUTTON', 'A', 'INPUT', 'SELECT', 'TEXTAREA'].includes(target.tagName)) {
+                this.toggle(this.host);
+            }
+        };
+    }
+    validatePlacement() {
+        checkEmptyOrOneOf(this, 'placement', PLACEMENT_TYPES);
+    }
+    connectedCallback() {
+        this.root = getRoot(this.host);
+        this.host.addEventListener('keydown', this.handleKeyDown);
+        this.host.addEventListener('click', this.handleClick);
+    }
+    disconnectedCallback() {
+        this.host.removeEventListener('keydown', this.handleKeyDown);
+        this.host.removeEventListener('click', this.handleClick);
+        this.popoverRef?.removeEventListener('postToggle', this.handlePostToggle);
+    }
+    componentDidLoad() {
+        this.validatePlacement();
+        if (this.popoverRef) {
+            this.popoverRef.addEventListener('postToggle', this.handlePostToggle);
+        }
+    }
+    /**
+     * Toggles the menu visibility based on its current state.
+     */
+    async toggle(target) {
+        if (this.popoverRef) {
+            await this.popoverRef.toggle(target);
+        }
+        else {
+            console.error('toggle: popoverRef is null or undefined');
+        }
+    }
+    /**
+     * Displays the popover menu, focusing the first menu item.
+     *
+     * @param target - The HTML element relative to which the popover menu should be displayed.
+     */
+    async show(target) {
+        if (this.popoverRef) {
+            await this.popoverRef.show(target);
+        }
+        else {
+            console.error('show: popoverRef is null or undefined');
+        }
+    }
+    /**
+     * Hides the popover menu and restores focus to the previously focused element.
+     */
+    async hide() {
+        if (this.popoverRef) {
+            await this.popoverRef.hide();
+        }
+        else {
+            console.error('hide: popoverRef is null or undefined');
+        }
+    }
+    controlKeyDownHandler(e) {
+        const menuItems = this.getSlottedItems();
+        if (!menuItems.length) {
+            return;
+        }
+        let currentIndex = menuItems.findIndex(el => {
+            // Check if the item is currently focused within its rendered scope (document or shadow root)
+            return el === getRoot(el).activeElement;
+        });
+        switch (e.key) {
+            case this.KEYCODES.UP:
+                e.preventDefault();
+                currentIndex = (currentIndex - 1 + menuItems.length) % menuItems.length;
+                break;
+            case this.KEYCODES.DOWN:
+                e.preventDefault();
+                currentIndex = (currentIndex + 1) % menuItems.length;
+                break;
+            case this.KEYCODES.HOME:
+                currentIndex = 0;
+                break;
+            case this.KEYCODES.END:
+                e.preventDefault();
+                currentIndex = menuItems.length - 1;
+                break;
+            case this.KEYCODES.SPACE:
+                this.toggle(this.host);
+                return;
+            case this.KEYCODES.TAB:
+                this.toggle(this.host);
+                break;
+        }
+        if (menuItems[currentIndex]) {
+            menuItems[currentIndex].focus();
+        }
+    }
+    getSlottedItems() {
+        const slot = this.host.shadowRoot.querySelector('slot');
+        const slottedElements = slot ? slot.assignedElements() : [];
+        return (slottedElements
+            // If the element is a slot, get the assigned elements
+            .flatMap(el => (el instanceof HTMLSlotElement ? el.assignedElements() : el))
+            // For each menu item, get any focusable children (e.g., buttons, links)
+            .flatMap(el => Array.from(getFocusableChildren(el))));
+    }
+    render() {
+        return (h(Host, { key: 'ee365a30646247563fccd55556f7667cb1591d02', "data-version": version, role: "menu" }, h("post-popovercontainer", { key: 'c649841d408d3f35dfed959cdc6b041163ff80d3', placement: this.placement, ref: e => (this.popoverRef = e) }, h("div", { key: '9f4f145b80c716d27dc51f4bcb0d269b2b2678a8', part: "menu" }, h("slot", { key: '72b53c8f154a4a91541799a789e8618a8d1a9c2c' })))));
+    }
+    get host() { return this; }
+    static get watchers() { return {
+        "placement": ["validatePlacement"]
+    }; }
+    static get style() { return postMenuCss; }
+}, [1, "post-menu", {
+        "placement": [1],
+        "isVisible": [32],
+        "toggle": [64],
+        "show": [64],
+        "hide": [64]
+    }, undefined, {
+        "placement": ["validatePlacement"]
+    }]);
+__decorate([
+    EventFrom('post-popovercontainer')
+], PostMenu.prototype, "handlePostToggle", void 0);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["post-menu", "post-popovercontainer"];
+    components.forEach(tagName => { switch (tagName) {
+        case "post-menu":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, PostMenu);
+            }
+            break;
+        case "post-popovercontainer":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { PostMenu as P, defineCustomElement as d };

package/dist/components/post-popover.js

@@ -1,8 +1,8 @@
-import { p as proxyCustomElement, H, h, a as Host } from './index.js';
-import { d as defineCustomElement$2, a as PLACEMENT_TYPES } from './p-D1Ldeko3.js';
-import { v as version } from './p-7hVD-I9l.js';
-import { I as IS_BROWSER } from './p-CJ80BZ06.js';
-import { d as checkEmptyOrOneOf, c as checkRequiredAndType } from './p-CV7fm1rW.js';
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { a as PLACEMENT_TYPES, d as defineCustomElement$2 } from './post-popovercontainer2.js';
+import { v as version } from './package.js';
+import { I as IS_BROWSER } from './breakpoints.js';
+import { d as checkEmptyOrOneOf, c as checkRequiredAndType } from './index2.js';
 
 function getAttributeObserver(attribute, handler) {
     /**
@@ -49,7 +49,7 @@ const globalToggleHandler = (e) => {
     const popover = document.getElementById(popoverTarget);
     popover?.toggle(currentElement);
 };
-const PostPopover$1 = /*@__PURE__*/ proxyCustomElement(class PostPopover extends H {
+const PostPopover$1 = /*@__PURE__*/ proxyCustomElement(class PostPopover extends HTMLElement {
     validatePlacement() {
         checkEmptyOrOneOf(this, 'placement', PLACEMENT_TYPES);
     }
@@ -181,7 +181,6 @@ function defineCustomElement$1() {
             break;
     } });
 }
-defineCustomElement$1();
 
 const PostPopover = PostPopover$1;
 const defineCustomElement = defineCustomElement$1;

package/dist/components/post-popovercontainer.js

@@ -1,4 +1,4 @@
-import { P as PostPopovercontainer$1, d as defineCustomElement$1 } from './p-D1Ldeko3.js';
+import { P as PostPopovercontainer$1, d as defineCustomElement$1 } from './post-popovercontainer2.js';
 
 const PostPopovercontainer = PostPopovercontainer$1;
 const defineCustomElement = defineCustomElement$1;