@siemens/ix 0.0.0-pr-1318-20240627080522 → 0.0.0-pr-1522-20241021144048

package/components/dropdown.js

@@ -1,5 +1,21 @@
-import { proxyCustomElement, HTMLElement as HTMLElement$1, createEvent, h, Host } from '@stencil/core/internal/client';
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
 import { f as flip, i as inline, s as shift, o as offset, a as autoUpdate, c as computePosition } from './floating-ui.dom.esm.js';
+import { d as dropdownController, h as hasDropdownItemWrapperImplemented } from './dropdown-controller.js';
+
+/*
+ * SPDX-FileCopyrightText: 2024 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const addDisposableEventListener = (element, eventType, callback) => {
+    element.addEventListener(eventType, callback);
+    return () => {
+        element.removeEventListener(eventType, callback);
+    };
+};
 
 /*
  * SPDX-FileCopyrightText: 2023 Siemens AG
@@ -12,14 +28,19 @@ import { f as flip, i as inline, s as shift, o as offset, a as autoUpdate, c as
 class ArrowFocusController {
     constructor(items, container, callback) {
         this.wrap = false;
-        this.keyListenerBind = this.keyListener.bind(this);
         this.items = items;
         this.container = container;
         this.callback = callback;
-        this.container.addEventListener('keydown', this.keyListenerBind);
+        this.keyListener = addDisposableEventListener(container, 'keydown', (e) => this.onKeyDown(e));
+    }
+    getActiveIndex() {
+        if (!document.activeElement) {
+            return -1;
+        }
+        return this.items.indexOf(document.activeElement);
     }
-    keyListener(e) {
-        const activeIndex = this.items.indexOf(document.activeElement);
+    onKeyDown(e) {
+        const activeIndex = this.getActiveIndex();
         if (activeIndex < 0) {
             return;
         }
@@ -27,196 +48,52 @@ class ArrowFocusController {
             case 'ArrowDown':
                 if (activeIndex < this.items.length - 1) {
                     e.preventDefault();
-                    if (this.callback) {
-                        this.callback(activeIndex + 1);
-                    }
+                    this.callback(activeIndex + 1);
                 }
                 else if (this.wrap) {
                     e.preventDefault();
-                    if (this.callback) {
-                        this.callback(0);
-                    }
+                    this.callback(0);
                 }
                 break;
             case 'ArrowUp':
                 {
                     if (activeIndex > 0) {
                         e.preventDefault();
-                        if (this.callback) {
-                            this.callback(activeIndex - 1);
-                        }
+                        this.callback(activeIndex - 1);
                     }
                     else if (this.wrap && activeIndex === 0) {
                         e.preventDefault();
-                        if (this.callback) {
-                            this.callback(this.items.length - 1);
-                        }
+                        this.callback(this.items.length - 1);
                     }
                 }
                 break;
         }
     }
     disconnect() {
-        this.container.removeEventListener('keydown', this.keyListenerBind);
-    }
-}
-
-/*
- * SPDX-FileCopyrightText: 2024 Siemens AG
- *
- * SPDX-License-Identifier: MIT
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-function hasDropdownItemWrapperImplemented(item) {
-    return (item &&
-        item.getDropdownItemElement !== undefined &&
-        typeof item.getDropdownItemElement === 'function');
-}
-class DropdownController {
-    constructor() {
-        this.dropdowns = new Map();
-        this.submenuIds = {};
-        this.isWindowListenerActive = false;
-    }
-    connected(dropdown) {
-        if (!this.isWindowListenerActive) {
-            this.addOverlayListeners();
-        }
-        this.dropdowns.set(dropdown.getId(), dropdown);
-        if (dropdown.discoverAllSubmenus) {
-            this.discoverSubmenus();
-        }
-    }
-    disconnected(dropdown) {
-        this.dropdowns.delete(dropdown.getId());
-    }
-    getDropdownById(id) {
-        return this.dropdowns.get(id);
-    }
-    discoverSubmenus() {
-        this.dropdowns.forEach((dropdown) => {
-            dropdown.discoverSubmenu();
-        });
-    }
-    present(dropdown) {
-        if (!dropdown.isPresent() && dropdown.willPresent()) {
-            this.submenuIds[dropdown.getId()] = dropdown.getAssignedSubmenuIds();
-            dropdown.present();
-        }
-    }
-    dismissChildren(uid) {
-        const childIds = this.submenuIds[uid] || [];
-        for (const id of childIds) {
-            this.dismiss(this.dropdowns.get(id));
+        if (this.keyListener) {
+            this.keyListener();
         }
-    }
-    dismiss(dropdown) {
-        if (dropdown.isPresent() && dropdown.willDismiss()) {
-            this.dismissChildren(dropdown.getId());
-            dropdown.dismiss();
-            delete this.submenuIds[dropdown.getId()];
-        }
-    }
-    dismissAll(ignoreBehaviorForIds = [], ignoreRelatedDropdowns = false) {
-        this.dropdowns.forEach((dropdown) => {
-            const preventClosing = dropdown.closeBehavior === 'inside' || dropdown.closeBehavior === false;
-            const shouldIgnore = ignoreBehaviorForIds.includes(dropdown.getId());
-            const path = this.buildComposedPath(dropdown.getId(), new Set());
-            if (ignoreBehaviorForIds.length > 0 && ignoreRelatedDropdowns) {
-                let skipRelatedDropdown = false;
-                ignoreBehaviorForIds.forEach((id) => {
-                    if (path.has(id)) {
-                        skipRelatedDropdown = true;
-                        return;
-                    }
-                });
-                if (!skipRelatedDropdown) {
-                    return;
-                }
-            }
-            if (!shouldIgnore && preventClosing) {
-                return;
-            }
-            this.dismiss(dropdown);
-        });
-    }
-    dismissOthers(uid) {
-        let path = this.buildComposedPath(uid, new Set());
-        path.add(uid);
-        this.dropdowns.forEach((dropdown) => {
-            if (dropdown.closeBehavior !== 'inside' &&
-                dropdown.closeBehavior !== false &&
-                !path.has(dropdown.getId())) {
-                this.dismiss(dropdown);
-            }
-        });
-    }
-    pathIncludesTrigger(eventTargets) {
-        for (let eventTarget of eventTargets) {
-            if (eventTarget instanceof HTMLElement) {
-                if (eventTarget.hasAttribute('data-ix-dropdown-trigger')) {
-                    return eventTarget;
-                }
-            }
-        }
-        return;
-    }
-    pathIncludesDropdown(eventTargets) {
-        return !!eventTargets.find((element) => element.tagName === 'IX-DROPDOWN');
-    }
-    buildComposedPath(id, path) {
-        if (this.submenuIds[id]) {
-            path.add(id);
-        }
-        for (const ruleKey of Object.keys(this.submenuIds)) {
-            if (this.submenuIds[ruleKey].includes(id)) {
-                this.buildComposedPath(ruleKey, path).forEach((key) => path.add(key));
-            }
-        }
-        return path;
-    }
-    addOverlayListeners() {
-        this.isWindowListenerActive = true;
-        window.addEventListener('click', (event) => {
-            const hasTrigger = this.pathIncludesTrigger(event.composedPath());
-            const hasDropdown = this.pathIncludesDropdown(event.composedPath());
-            if (!hasTrigger && !hasDropdown) {
-                this.dismissAll();
-            }
-        });
-        window.addEventListener('keydown', (event) => {
-            if (event.key === 'Escape') {
-                this.dismissAll([...this.dropdowns.keys()]);
-            }
-        });
+        this.container = undefined;
+        this.callback = undefined;
     }
 }
-const addDisposableEventListener = (element, eventType, callback) => {
-    element.addEventListener(eventType, callback);
-    return () => {
-        element.removeEventListener(eventType, callback);
-    };
-};
-const dropdownController = new DropdownController();
 
 const dropdownCss = ":host{background-color:var(--theme-color-2);border-radius:var(--theme-default-border-radius);min-width:0px;z-index:var(--theme-z-index-dropdown);box-shadow:var(--theme-shadow-4);padding:0.25rem 0px}:host *,:host *::after,:host *::before{box-sizing:border-box}:host ::-webkit-scrollbar-button{display:none}@-moz-document url-prefix(){:host *{scrollbar-color:var(--theme-scrollbar-thumb--background) var(--theme-scrollbar-track--background);scrollbar-width:thin}}:host ::-webkit-scrollbar{width:0.5rem;height:0.5rem}:host ::-webkit-scrollbar-track{border-radius:5px;background:var(--theme-scrollbar-track--background)}:host ::-webkit-scrollbar-track:hover{background:var(--theme-scrollbar-track--background--hover)}:host ::-webkit-scrollbar-thumb{border-radius:5px;background:var(--theme-scrollbar-thumb--background)}:host ::-webkit-scrollbar-thumb:hover{background:var(--theme-scrollbar-thumb--background--hover)}:host ::-webkit-scrollbar-corner{display:none}:host .dropdown-header{display:flex;align-items:center;height:2.5rem;color:var(--theme-menu-header--color);padding:0 1rem}:host(.overflow){max-height:50vh;overflow-y:auto}:host(:not(.show)){display:none}";
 const IxDropdownStyle0 = dropdownCss;
 
 let sequenceId = 0;
-const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLElement$1 {
+const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLElement {
     constructor() {
         super();
         this.__registerHost();
         this.__attachShadow();
         this.showChanged = createEvent(this, "showChanged", 7);
-        this.autoUpdateCleanup = null;
         this.localUId = `dropdown-${sequenceId++}`;
         this.assignedSubmenu = [];
-        this.focusDropdownItemBind = this.focusDropdownItem.bind(this);
         this.itemObserver = new MutationObserver(() => {
-            this.arrowFocusController.items = this.dropdownItems;
+            if (this.arrowFocusController) {
+                this.arrowFocusController.items = this.dropdownItems;
+            }
         });
         this.suppressAutomaticPlacement = false;
         this.show = false;
@@ -246,16 +123,28 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
         }
     }
     disconnectedCallback() {
+        var _a;
         dropdownController.dismiss(this);
         dropdownController.disconnected(this);
+        if (this.arrowFocusController) {
+            (_a = this.arrowFocusController) === null || _a === void 0 ? void 0 : _a.disconnect();
+            this.arrowFocusController = undefined;
+        }
+        if (this.itemObserver) {
+            this.itemObserver.disconnect();
+            this.itemObserver = undefined;
+        }
         if (this.disposeClickListener) {
             this.disposeClickListener();
+            this.disposeClickListener = undefined;
         }
         if (this.disposeKeyListener) {
             this.disposeKeyListener();
+            this.disposeKeyListener = undefined;
         }
         if (this.autoUpdateCleanup) {
             this.autoUpdateCleanup();
+            this.autoUpdateCleanup = undefined;
         }
     }
     getAssignedSubmenuIds() {
@@ -300,6 +189,9 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
             }
             dropdownController.dismissOthers(this.getId());
         };
+        if (!this.triggerElement) {
+            return;
+        }
         this.disposeClickListener = addDisposableEventListener(this.triggerElement, 'click', (event) => {
             if (!event.defaultPrevented) {
                 toggleController();
@@ -321,7 +213,7 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
         if (!this.triggerElement) {
             return;
         }
-        this.disposeKeyListener = addDisposableEventListener(this.triggerElement, 'keydown', (event) => {
+        this.disposeKeyListener = addDisposableEventListener(this.triggerElement, 'keydown', ((event) => {
             if (event.key !== 'ArrowDown') {
                 return;
             }
@@ -332,7 +224,7 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
             setTimeout(() => {
                 this.focusDropdownItem(0);
             });
-        });
+        }));
     }
     async registerListener(element) {
         this.triggerElement = await this.resolveElement(element);
@@ -347,7 +239,7 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
     }
     async checkForSubmenuAnchor(element) {
         if (!element) {
-            return null;
+            return undefined;
         }
         if (hasDropdownItemWrapperImplemented(element)) {
             const dropdownItem = await element.getDropdownItemElement();
@@ -368,16 +260,18 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
             return Promise.resolve(element);
         }
         if (typeof element != 'string') {
-            return;
+            return Promise.resolve(undefined);
         }
         const selector = `#${element}`;
         return new Promise((resolve) => {
-            if (document.querySelector(selector)) {
-                return resolve(document.querySelector(selector));
+            const el = document.querySelector(selector);
+            if (el !== null) {
+                return resolve(el);
             }
             const observer = new MutationObserver(() => {
-                if (document.querySelector(selector)) {
-                    resolve(document.querySelector(selector));
+                const el = document.querySelector(selector);
+                if (el) {
+                    resolve(el);
                     observer.disconnect();
                 }
             });
@@ -387,31 +281,44 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
             });
         });
     }
+    async resolveAnchorElement() {
+        if (this.anchor) {
+            this.anchorElement = await this.resolveElement(this.anchor);
+        }
+        else if (this.trigger) {
+            this.anchorElement = await this.resolveElement(this.trigger);
+        }
+    }
     async changedShow(newShow) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if (newShow) {
-            this.anchorElement = await (this.anchor
-                ? this.resolveElement(this.anchor)
-                : this.resolveElement(this.trigger));
+            await this.resolveAnchorElement();
             if (this.anchorElement) {
                 this.applyDropdownPosition();
             }
-            this.arrowFocusController = new ArrowFocusController(this.dropdownItems, this.dropdownRef, this.focusDropdownItemBind);
-            this.itemObserver.observe(this.dropdownRef, {
+            this.arrowFocusController = new ArrowFocusController(this.dropdownItems, this.hostElement, (index) => this.focusDropdownItem(index));
+            (_a = this.itemObserver) === null || _a === void 0 ? void 0 : _a.observe(this.hostElement, {
                 childList: true,
                 subtree: true,
             });
             this.registerKeyListener();
         }
         else {
-            (_a = this.arrowFocusController) === null || _a === void 0 ? void 0 : _a.disconnect();
-            (_b = this.itemObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
-            (_c = this.disposeKeyListener) === null || _c === void 0 ? void 0 : _c.call(this);
+            this.destroyAutoUpdate();
+            (_b = this.arrowFocusController) === null || _b === void 0 ? void 0 : _b.disconnect();
+            (_c = this.itemObserver) === null || _c === void 0 ? void 0 : _c.disconnect();
+            (_d = this.disposeKeyListener) === null || _d === void 0 ? void 0 : _d.call(this);
         }
     }
     changedTrigger(newTriggerValue) {
         this.registerListener(newTriggerValue);
     }
+    destroyAutoUpdate() {
+        if (this.autoUpdateCleanup) {
+            this.autoUpdateCleanup();
+            this.autoUpdateCleanup = undefined;
+        }
+    }
     isAnchorSubmenu() {
         var _a;
         if (!hasDropdownItemWrapperImplemented(this.anchorElement)) {
@@ -422,49 +329,49 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
         return true;
     }
     async applyDropdownPosition() {
+        var _a, _b;
         if (!this.show) {
             return;
         }
         if (!this.anchorElement) {
             return;
         }
-        if (!this.dropdownRef) {
-            return;
-        }
         const isSubmenu = this.isAnchorSubmenu();
         let positionConfig = {
             strategy: this.positioningStrategy,
             middleware: [],
         };
         if (!this.suppressAutomaticPlacement) {
-            positionConfig.middleware.push(flip({ fallbackStrategy: 'initialPlacement' }));
+            (_a = positionConfig.middleware) === null || _a === void 0 ? void 0 : _a.push(flip({ fallbackStrategy: 'initialPlacement' }));
         }
         positionConfig.placement = isSubmenu ? 'right-start' : this.placement;
         positionConfig.middleware = [
-            ...positionConfig.middleware,
+            ...(((_b = positionConfig.middleware) === null || _b === void 0 ? void 0 : _b.filter(Boolean)) || []),
             inline(),
             shift(),
         ];
         if (this.offset) {
             positionConfig.middleware.push(offset(this.offset));
         }
-        if (this.autoUpdateCleanup) {
-            this.autoUpdateCleanup();
-            this.autoUpdateCleanup = null;
-        }
-        this.autoUpdateCleanup = autoUpdate(this.anchorElement, this.dropdownRef, async () => {
-            const computeResponse = await computePosition(this.anchorElement, this.dropdownRef, positionConfig);
-            Object.assign(this.dropdownRef.style, {
-                top: '0',
-                left: '0',
-                transform: `translate(${Math.round(computeResponse.x)}px,${Math.round(computeResponse.y)}px)`,
-            });
+        this.destroyAutoUpdate();
+        if (!this.anchorElement) {
+            return;
+        }
+        this.autoUpdateCleanup = autoUpdate(this.anchorElement, this.hostElement, async () => {
+            if (this.anchorElement) {
+                const computeResponse = await computePosition(this.anchorElement, this.hostElement, positionConfig);
+                Object.assign(this.hostElement.style, {
+                    top: '0',
+                    left: '0',
+                    transform: `translate(${Math.round(computeResponse.x)}px,${Math.round(computeResponse.y)}px)`,
+                });
+            }
             if (this.overwriteDropdownStyle) {
                 const overwriteStyle = await this.overwriteDropdownStyle({
-                    dropdownRef: this.dropdownRef,
+                    dropdownRef: this.hostElement,
                     triggerRef: this.triggerElement,
                 });
-                Object.assign(this.dropdownRef.style, overwriteStyle);
+                Object.assign(this.hostElement.style, overwriteStyle);
             }
         }, {
             ancestorResize: true,
@@ -474,18 +381,22 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
     }
     focusDropdownItem(index) {
         requestAnimationFrame(() => {
-            var _a;
-            (_a = this.dropdownItems[index]) === null || _a === void 0 ? void 0 : _a.shadowRoot.querySelector('button').focus();
+            var _a, _b;
+            const button = (_b = (_a = this.dropdownItems[index]) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('button');
+            if (button) {
+                button.focus();
+            }
         });
     }
     async componentDidLoad() {
+        if (!this.trigger) {
+            return;
+        }
         this.changedTrigger(this.trigger);
     }
     async componentDidRender() {
         await this.applyDropdownPosition();
-        this.anchorElement = await (this.anchor
-            ? this.resolveElement(this.anchor)
-            : this.resolveElement(this.trigger));
+        await this.resolveAnchorElement();
     }
     isTriggerElement(element) {
         const trigger = !!element.hasAttribute('data-ix-dropdown-trigger');
@@ -498,6 +409,9 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
                 event.preventDefault();
             }
             if (this.isTriggerElement(target)) {
+                if (this.closeBehavior === 'outside') {
+                    event.preventDefault();
+                }
                 return;
             }
         }
@@ -515,7 +429,7 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
         this.applyDropdownPosition();
     }
     render() {
-        return (h(Host, { key: 'c5fa949b336dfa2d85453647ec285661866b4c05', "data-ix-dropdown": this.localUId, ref: (ref) => (this.dropdownRef = ref), class: {
+        return (h(Host, { key: '142e41faac492d0151d8e6296347cae8493c987e', "data-ix-dropdown": this.localUId, class: {
                 'dropdown-menu': true,
                 show: this.show,
                 overflow: true,
@@ -523,7 +437,7 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
                 margin: '0',
                 minWidth: '0px',
                 position: this.positioningStrategy,
-            }, role: "list", onClick: (event) => this.onDropdownClick(event) }, h("div", { key: 'bd0b94a0f4f12fe426ea040eba252e2b571f10a2', style: { display: 'contents' } }, this.header && h("div", { key: '353ea10f7608c8a822058eb869345ca0178f4c91', class: "dropdown-header" }, this.header), h("slot", { key: 'b573d70610827470688dc4369d152fcdf55bdd3d' }))));
+            }, role: "list", onClick: (event) => this.onDropdownClick(event) }, h("div", { key: '4a8728f504cf254a15243198602fd724b63eac30', style: { display: 'contents' } }, this.header && h("div", { key: 'a7a95fb9beed05a81808abdace48431184bf7f21', class: "dropdown-header" }, this.header), this.show && h("slot", { key: '6443a96f351941bc26a0ef02055b15be8e7782cf' }))));
     }
     get hostElement() { return this; }
     static get watchers() { return {
@@ -534,8 +448,8 @@ const Dropdown = /*@__PURE__*/ proxyCustomElement(class Dropdown extends HTMLEle
 }, [1, "ix-dropdown", {
         "suppressAutomaticPlacement": [4, "suppress-automatic-placement"],
         "show": [1540],
-        "trigger": [1],
-        "anchor": [1],
+        "trigger": [8],
+        "anchor": [8],
         "closeBehavior": [8, "close-behavior"],
         "placement": [1],
         "positioningStrategy": [1, "positioning-strategy"],
@@ -564,6 +478,6 @@ function defineCustomElement() {
     } });
 }
 
-export { ArrowFocusController as A, Dropdown as D, dropdownController as a, defineCustomElement as d };
+export { ArrowFocusController as A, Dropdown as D, addDisposableEventListener as a, defineCustomElement as d };
 
 //# sourceMappingURL=dropdown.js.map