@six-group/ui-library 0.0.0-insider.931e1d7 → 0.0.0-insider.93c8f70

package/dist/cjs/six-dropdown_2.cjs.entry.js

@@ -0,0 +1,798 @@
+'use strict';
+
+var index = require('./index-BKTrCUjx.js');
+var popover = require('./popover-BUVXXnz7.js');
+var eventListeners = require('./event-listeners-BrSR7arL.js');
+var executionControl = require('./execution-control-oU0MWBWI.js');
+var slot = require('./slot-DBK7c7jH.js');
+
+function isTabbable(el) {
+    const tabIndex = el.tabIndex;
+    return tabIndex > -1;
+}
+function getNearestTabbableElement(el) {
+    // Check the element
+    if (isTabbable(el)) {
+        return el;
+    }
+    // Check the element's shadow root
+    if (el.shadowRoot != null) {
+        const tabbableShadowChild = [...el.shadowRoot.children].find((e) => isTabbable(e));
+        if (tabbableShadowChild != null) {
+            return tabbableShadowChild;
+        }
+    }
+    // Check the element's children
+    if (el.children != null) {
+        return [...el.children].map((e) => getNearestTabbableElement(e)).at(0);
+    }
+    return undefined;
+}
+
+const sixDropdownCss = ":host{position:relative;box-sizing:border-box}:host *,:host *:before,:host *:after{box-sizing:border-box}.sr-only{clip:rect(0 0 0 0);clip-path:inset(50%);height:1px;overflow:hidden;position:absolute;white-space:nowrap;width:1px}:host{display:inline-block}.dropdown{position:relative}.dropdown__trigger{display:block}.dropdown__positioner{position:absolute;z-index:var(--six-z-index-dropdown)}.dropdown__positioner__filtered{width:100%}.dropdown__panel{font-family:var(--six-font-sans);font-size:var(--six-font-size-small);font-weight:var(--six-font-weight-normal);color:var(--color);background-color:var(--six-panel-background-color);border-radius:var(--six-border-radius-medium);border:1px solid var(--six-color-web-rock-300);box-shadow:var(--six-shadow-small);opacity:0;pointer-events:none;transform:scale(0.9);transition:var(--six-transition-fast) opacity, var(--six-transition-fast) transform;max-width:90vw}.dropdown__panel__scroll{max-height:18.75rem;overflow-y:auto;overflow-x:hidden;overscroll-behavior:none}.dropdown__panel__scroll--virtual{overflow-y:hidden;overflow-x:hidden}.filter-hidden{display:none}.dropdown__positioner[data-popper-placement^=top] .dropdown__panel{transform-origin:bottom}.dropdown__positioner[data-popper-placement^=bottom] .dropdown__panel{transform-origin:top}.dropdown__positioner[data-popper-placement^=left] .dropdown__panel{transform-origin:right}.dropdown__positioner[data-popper-placement^=right] .dropdown__panel{transform-origin:left}.dropdown__positioner.popover-visible .dropdown__panel{opacity:1;transform:none;pointer-events:all}.filter{border-bottom:1px solid var(--six-color-web-rock-300)}.filter__icon{color:var(--six-color-web-rock-600)}";
+
+let id = 0;
+const SixDropdown = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.sixShow = index.createEvent(this, "six-dropdown-show");
+        this.sixAfterShow = index.createEvent(this, "six-dropdown-after-show");
+        this.sixHide = index.createEvent(this, "six-dropdown-hide");
+        this.sixAfterHide = index.createEvent(this, "six-dropdown-after-hide");
+        this.sixAutoFilter = index.createEvent(this, "six-dropdown-auto-filter-fired");
+        this.sixAsyncFilterFired = index.createEvent(this, "six-async-filter-fired");
+        this.sixScroll = index.createEvent(this, "six-dropdown-scroll");
+        this.componentId = `dropdown-${++id}`;
+        this.isVisible = false;
+        this.resizeObserver = new ResizeObserver(executionControl.debounce(() => this.updatePanelPosition(), 100));
+        /** Indicates whether the dropdown is open. You can use this in lieu of the show/hide methods. */
+        this.open = false;
+        /**
+         * The preferred placement of the dropdown panel. Note that the actual placement may vary as needed to keep the panel
+         * inside the viewport.
+         */
+        this.placement = 'bottom-start';
+        /** Determines whether the dropdown should hide when a menu item is selected. */
+        // eslint-disable-next-line @stencil-community/ban-default-true
+        this.closeOnSelect = true;
+        /** The distance in pixels from which to offset the panel away from its trigger. */
+        this.distance = 4;
+        /** The distance in pixels from which to offset the panel along its trigger. */
+        this.skidding = 0;
+        /**
+         * Enable this option to prevent the panel from being clipped when the component is placed inside a container with
+         * `overflow: auto|scroll`.
+         */
+        this.hoist = false;
+        /**
+         * Set to true to allow auto filtering for entries in the dropdown.
+         * With this flag the dropdown will automatically filter itsel.
+         * If you need to coordinate the shown elements yourself,
+         * e.g. because you need to call an endpoint use asyncFilter instead
+         */
+        this.filter = false;
+        /**
+         * Set to true to allow async filtering.
+         * When you enter something in the search field the component will only emit an event but not filter any elements itself.
+         * You can then simply listen to the 'six-async-filter-fired' event to manage the shown menu-items yourself
+         */
+        this.asyncFilter = false;
+        /** The filter's placeholder text. */
+        this.filterPlaceholder = 'Filter...';
+        /** By default the search field will be focused when opening a dropdown with filtering enabled. */
+        // eslint-disable-next-line @stencil-community/ban-default-true
+        this.autofocusFilter = true;
+        /** The debounce for the filter callbacks. */
+        this.filterDebounce = 0;
+        /** The panel can be opend/closed by pressing the spacebar or the enter key. In some cases you might want to avoid this */
+        this.disableHideOnEnterAndSpace = false;
+        /** Set the options to be shown in the dropdown (alternative to setting the elements via html)*/
+        this.options = [];
+        /** Defines whether the menu list will be rendered virtually i.e. only the elements actually shown (and a couple around)
+         *  are actually rendered in the DOM. If you use virtual scrolling pass the elements via prop instead of via slot. */
+        this.virtualScroll = false;
+        /**
+         * Determines if the dropdown panel's width should match the width of the trigger element.
+         *
+         * If set to `true`, the panel will resize its width to align with the trigger's width.
+         * If `false` or omitted, the panel will maintain its default width.
+         */
+        this.matchTriggerWidth = false;
+        this.eventListeners = new eventListeners.EventListeners();
+        // internal representation of options, so we don't have to make options mutable
+        this.renderedOptions = [];
+        this.getMenuItems = () => {
+            var _a, _b, _c, _d;
+            if (this.options.length > 0) {
+                return {
+                    sixMenuItems: this.renderedOptions.map((option) => (index.h("six-menu-item", { value: option.value }, option.label))),
+                    selectionContainerItems: [],
+                };
+            }
+            if (this.panel == null)
+                return { sixMenuItems: [], selectionContainerItems: [] };
+            // Relies on the implementation of six-select. Its dropdown slot contains two elements,
+            // one for the selected menu items, and one for the other items.
+            const selectionContainer = (_a = this.panelSlot) === null || _a === void 0 ? void 0 : _a.assignedElements({ flatten: true }).filter(isSelectionContainer).at(0);
+            const sixMenuElement = (_b = this.panelSlot) === null || _b === void 0 ? void 0 : _b.assignedElements({ flatten: true }).filter(isSixMenu).at(0);
+            const selectionContainerItems = (selectionContainer === null || selectionContainer === void 0 ? void 0 : selectionContainer.querySelectorAll('six-menu-item')) || [];
+            let sixMenuItems = ((_c = sixMenuElement === null || sixMenuElement === void 0 ? void 0 : sixMenuElement.querySelector('slot')) === null || _c === void 0 ? void 0 : _c.assignedElements().filter((el) => isSixMenuItem(el))) || [];
+            if (sixMenuItems.length === 0) {
+                sixMenuItems = Array.from(((_d = sixMenuElement === null || sixMenuElement === void 0 ? void 0 : sixMenuElement.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelectorAll('six-menu-item')) || []);
+            }
+            if (selectionContainerItems.length > 0 || sixMenuItems.length > 0) {
+                return { sixMenuItems, selectionContainerItems: [...selectionContainerItems] };
+            }
+            else {
+                return {
+                    sixMenuItems: sixMenuElement ? Array.from(sixMenuElement.querySelectorAll('six-menu-item')) : [],
+                    selectionContainerItems: [],
+                };
+            }
+        };
+        this.handleDocumentKeyDown = (event) => {
+            var _a;
+            const keyboardEvent = event;
+            // Close when escape is pressed
+            if (keyboardEvent.key === 'Escape') {
+                void this.hide();
+                this.focusOnTrigger();
+                return;
+            }
+            if (this.filterInputElement === ((_a = this.host.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement)) {
+                if (keyboardEvent.key === 'ArrowDown') {
+                    const { sixMenuItems, selectionContainerItems } = this.getMenuItems();
+                    const item = [...selectionContainerItems, ...sixMenuItems].find((item) => item.style.display !== 'none');
+                    if (item != null) {
+                        item.setFocus();
+                    }
+                }
+            }
+            // Handle tabbing
+            if (keyboardEvent.key === 'Tab') {
+                // Tabbing within an open menu should close the dropdown and refocus the trigger
+                if (this.open && document.activeElement != null && isSixMenuItem(document.activeElement)) {
+                    keyboardEvent.preventDefault();
+                    void this.hide();
+                    this.focusOnTrigger();
+                    return;
+                }
+                // Tabbing outside the containing element closes the panel
+                //
+                // If the dropdown is used within a shadow DOM, we need to obtain the activeElement within that shadowRoot,
+                // otherwise `document.activeElement` will only return the name of the parent shadow DOM element.
+                setTimeout(() => {
+                    var _a, _b;
+                    const activeElement = this.container.getRootNode() instanceof ShadowRoot
+                        ? (_b = (_a = document.activeElement) === null || _a === void 0 ? void 0 : _a.shadowRoot) === null || _b === void 0 ? void 0 : _b.activeElement
+                        : document.activeElement;
+                    if ((activeElement === null || activeElement === void 0 ? void 0 : activeElement.closest(this.container.tagName.toLowerCase())) !== this.container) {
+                        void this.hide();
+                        return;
+                    }
+                });
+            }
+        };
+        this.handleDocumentMouseDown = (event) => {
+            // Close when clicking outside the containing element
+            const path = event.composedPath();
+            if (!path.includes(this.container)) {
+                void this.hide();
+                return;
+            }
+        };
+        this.handlePanelSelect = (event) => {
+            const target = event.target;
+            // Hide the dropdown when a menu item is selected
+            if (this.closeOnSelect && isSixMenu(target)) {
+                void this.hide();
+                this.focusOnTrigger();
+            }
+        };
+        this.handleTriggerClick = () => {
+            this.open ? this.hide() : this.show();
+        };
+        this.handleTriggerKeyDown = (event) => {
+            // Close when escape or tab is pressed
+            if (event.key === 'Escape') {
+                this.focusOnTrigger();
+                void this.hide();
+                return;
+            }
+            // When spacebar/enter is pressed, show the panel but don't focus on the menu. This let's the user press the same
+            // key again to hide the menu in case they don't want to make a selection.
+            if (!this.disableHideOnEnterAndSpace && [' ', 'Enter'].includes(event.key)) {
+                event.preventDefault();
+                this.open ? void this.hide() : void this.show();
+                return;
+            }
+            const menu = this.getMenu();
+            // When up/down is pressed, we make the assumption that the user is familiar with the menu and plans to make a
+            // selection. Rather than toggle the panel, we focus on the menu (if one exists) and activate the first item for
+            // faster navigation.
+            if (['ArrowDown', 'ArrowUp'].includes(event.key)) {
+                event.preventDefault();
+                // Show the menu if it's not already open
+                if (!this.open) {
+                    void this.show();
+                }
+                if (menu == null) {
+                    return;
+                }
+                const menuItems = [...menu.querySelectorAll('six-menu-item')];
+                const firstMenuItem = menuItems.at(0);
+                const lastMenuItem = menuItems.at(menuItems.length - 1);
+                // Focus on a menu item
+                if (event.key === 'ArrowDown' && firstMenuItem != null) {
+                    firstMenuItem.setFocus();
+                    return;
+                }
+                if (event.key === 'ArrowUp' && lastMenuItem != null) {
+                    lastMenuItem.setFocus();
+                    return;
+                }
+            }
+            // Other keys bring focus to the menu and initiate type-to-select behavior
+            const ignoredKeys = ['Tab', 'Shift', 'Meta', 'Ctrl', 'Alt'];
+            if (this.open && menu != null && !ignoredKeys.includes(event.key)) {
+                void menu.typeToSelect(event.key);
+                return;
+            }
+        };
+        this.handleTriggerKeyUp = (event) => {
+            // Prevent space from triggering a click event in Firefox
+            if (event.key === ' ') {
+                event.preventDefault();
+            }
+        };
+        this.handleTriggerSlotChange = () => {
+            this.updateAccessibleTrigger();
+        };
+        this.handleDropdownScroll = () => {
+            if (this.scrollPanel == null)
+                return;
+            this.sixScroll.emit({
+                scrollHeight: this.scrollPanel.scrollHeight,
+                scrollTop: this.scrollPanel.scrollTop,
+                scrollbarHeight: this.scrollPanel.offsetHeight * (this.scrollPanel.offsetHeight / this.scrollPanel.scrollHeight),
+                scrollRatio: this.scrollPanel.scrollTop / (this.scrollPanel.scrollHeight - this.scrollPanel.clientHeight),
+            });
+        };
+    }
+    get filterEnabled() {
+        return this.filter || this.asyncFilter;
+    }
+    get container() {
+        return this.containingElement || this.host;
+    }
+    handleOpenChange() {
+        this.open ? this.show() : this.hide();
+        this.updateAccessibleTrigger();
+    }
+    handlePopoverOptionsChange() {
+        if (this.popoverHelper == null)
+            return;
+        this.popoverHelper.setOptions({
+            strategy: this.hoist ? 'fixed' : 'absolute',
+            placement: this.placement,
+            distance: this.distance,
+            skidding: this.skidding,
+        });
+    }
+    handleOptionsChange() {
+        this.validateOptions();
+    }
+    validateOptions() {
+        if (!Array.isArray(this.options)) {
+            this.options = [];
+        }
+        if (this.virtualScroll && this.options.length === 0) {
+            console.error('Options must be defined when using virtual scrolling');
+        }
+        this.renderedOptions = [...this.options];
+    }
+    componentWillLoad() {
+        this.validateOptions();
+        if (this.asyncFilter) {
+            this.filterDebounce = executionControl.DEFAULT_DEBOUNCE_FAST;
+        }
+    }
+    componentDidLoad() {
+        this.init();
+        if (this.open) {
+            void this.show();
+        }
+    }
+    connectedCallback() {
+        this.init();
+    }
+    init() {
+        this.initPopover();
+        // listen to filter
+        const filterInputElement = this.filterInputElement;
+        if (filterInputElement != null) {
+            this.eventListeners.add(filterInputElement, 'six-input-input', executionControl.debounce(() => {
+                var _a;
+                const filterValue = (_a = filterInputElement.value) !== null && _a !== void 0 ? _a : '';
+                if (this.filter) {
+                    this.applyFilter(filterValue);
+                }
+                this.emitFilterEvents(filterValue);
+            }, this.filterDebounce));
+        }
+    }
+    applyFilter(filterTerm) {
+        var _a;
+        const lowerCaseFilterTerm = ((_a = filterTerm.toLowerCase()) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+        if (this.options.length > 0) {
+            this.renderedOptions = this.options.filter((option) => {
+                var _a, _b, _c, _d;
+                return (option.label && ((_b = (_a = String(option.label)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes(lowerCaseFilterTerm))) ||
+                    (option.value && ((_d = (_c = String(option.value)) === null || _c === void 0 ? void 0 : _c.toLowerCase()) === null || _d === void 0 ? void 0 : _d.includes(lowerCaseFilterTerm)));
+            });
+        }
+        else {
+            const { selectionContainerItems, sixMenuItems } = this.getMenuItems();
+            const selectionContainerValues = selectionContainerItems.map((s) => s.value);
+            // Filter items in selection container
+            selectionContainerItems.forEach(async (menuItem) => {
+                menuItem.style.display = (await containsFilterTerm(menuItem, lowerCaseFilterTerm)) ? 'unset' : 'none';
+            });
+            // Filter other items. Always hide items which contained in the selection container.
+            sixMenuItems.forEach(async (menuItem) => {
+                menuItem.style.display =
+                    (await containsFilterTerm(menuItem, lowerCaseFilterTerm)) &&
+                        !selectionContainerValues.includes(menuItem.value)
+                        ? 'unset'
+                        : 'none';
+            });
+        }
+    }
+    resetFilter() {
+        if (this.filterInputElement != null) {
+            this.filterInputElement.value = '';
+            this.emitFilterEvents('');
+        }
+        if (this.options.length > 0) {
+            this.renderedOptions = [...this.options];
+        }
+        else {
+            const { selectionContainerItems, sixMenuItems } = this.getMenuItems();
+            [...selectionContainerItems, ...sixMenuItems].forEach((item) => (item.style.display = 'unset'));
+        }
+    }
+    emitFilterEvents(filterValue) {
+        if (this.filter) {
+            this.sixAutoFilter.emit({ filterValue });
+        }
+        else if (this.asyncFilter) {
+            this.sixAsyncFilterFired.emit({ filterValue });
+        }
+    }
+    initPopover() {
+        if (this.trigger == null || this.positioner == null)
+            return;
+        this.popoverHelper = new popover.Popover(this.trigger, this.positioner, {
+            strategy: this.hoist ? 'fixed' : 'absolute',
+            placement: this.placement,
+            distance: this.distance,
+            skidding: this.skidding,
+            transitionElement: this.panel,
+            onAfterHide: () => {
+                if (this.filterEnabled) {
+                    this.resetFilter();
+                }
+                this.sixAfterHide.emit();
+            },
+            onAfterShow: async () => {
+                this.sixAfterShow.emit();
+            },
+            onTransitionEnd: () => {
+                if (!this.open && this.scrollPanel != null) {
+                    this.scrollPanel.scrollTop = 0;
+                }
+            },
+        });
+    }
+    disconnectedCallback() {
+        var _a;
+        this.resizeObserver.disconnect();
+        this.eventListeners.removeAll();
+        void this.hide();
+        (_a = this.popoverHelper) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.popoverHelper = undefined;
+    }
+    /** Shows the dropdown panel */
+    async show() {
+        // Prevent subsequent calls to the method, whether manually or triggered by the `open` watcher
+        if (this.isVisible || this.popoverHelper == null || this.panel == null) {
+            return;
+        }
+        const sixShow = this.sixShow.emit();
+        if (sixShow.defaultPrevented) {
+            this.open = false;
+            return;
+        }
+        this.eventListeners.add(this.panel, 'six-menu-item-selected', this.handlePanelSelect);
+        this.eventListeners.add(document, 'keydown', this.handleDocumentKeyDown);
+        this.eventListeners.add(document, 'mousedown', this.handleDocumentMouseDown);
+        this.isVisible = true;
+        this.open = true;
+        if (this.trigger != null) {
+            this.resizeObserver.observe(this.trigger);
+        }
+        this.updatePanelPosition();
+        this.popoverHelper.show();
+        if (this.filterEnabled && this.autofocusFilter) {
+            requestAnimationFrame(() => {
+                var _a;
+                (_a = this.filterInputElement) === null || _a === void 0 ? void 0 : _a.setFocus();
+            });
+        }
+    }
+    /**
+     * Set min width of dropdown panel to the width of the trigger element
+     */
+    updatePanelPosition() {
+        if (!this.open) {
+            return;
+        }
+        if (this.matchTriggerWidth && this.trigger != null && this.panel != null) {
+            const width = this.trigger.getBoundingClientRect().width;
+            this.panel.style.minWidth = `${width}px`;
+        }
+        if (this.popoverHelper != null) {
+            this.popoverHelper.reposition();
+        }
+    }
+    /** Hides the dropdown panel */
+    async hide() {
+        this.resizeObserver.disconnect();
+        // Prevent subsequent calls to the method, whether manually or triggered by the `open` watcher
+        if (!this.isVisible || this.panel == null || this.popoverHelper == null) {
+            return;
+        }
+        const sixHide = this.sixHide.emit();
+        if (sixHide.defaultPrevented) {
+            this.open = true;
+            return;
+        }
+        this.eventListeners.remove(this.panel, 'six-menu-item-selected', this.handlePanelSelect);
+        this.eventListeners.remove(document, 'keydown', this.handleDocumentKeyDown);
+        this.eventListeners.remove(document, 'mousedown', this.handleDocumentMouseDown);
+        this.isVisible = false;
+        this.open = false;
+        this.popoverHelper.hide();
+    }
+    focusOnTrigger() {
+        var _a;
+        if (this.trigger == null)
+            return;
+        const trigger = (_a = this.triggerSlot) === null || _a === void 0 ? void 0 : _a.assignedElements({ flatten: true }).at(0);
+        if (trigger != null) {
+            if (typeof trigger.setFocus === 'function') {
+                trigger.setFocus();
+            }
+            else if (typeof trigger.focus === 'function') {
+                trigger.focus();
+            }
+        }
+    }
+    getMenu() {
+        var _a;
+        return (_a = this.panelSlot) === null || _a === void 0 ? void 0 : _a.assignedElements({ flatten: true }).filter(isSixMenu).at(0);
+    }
+    //
+    // Slotted triggers can be arbitrary content, but we need to link them to the dropdown panel with `aria-haspopup` and
+    // `aria-expanded`. These must be applied to the "accessible trigger" (the tabbable portion of the trigger element
+    // that gets slotted in) so screen readers will understand them. The accessible trigger could be the slotted element,
+    // a child of the slotted element, or an element in the slotted element's shadow root.
+    //
+    // For example, the accessible trigger of an <sl-button> is a <button> located inside its shadow root.
+    //
+    // To determine this, we assume the first tabbable element in the trigger slot is the "accessible trigger."
+    //
+    updateAccessibleTrigger() {
+        var _a;
+        if (this.trigger == null)
+            return;
+        const assignedElements = (((_a = this.triggerSlot) === null || _a === void 0 ? void 0 : _a.assignedElements({ flatten: true })) || []);
+        const accessibleTrigger = assignedElements.map(getNearestTabbableElement).at(0);
+        if (accessibleTrigger != null) {
+            accessibleTrigger.setAttribute('aria-haspopup', 'true');
+            accessibleTrigger.setAttribute('aria-expanded', this.open ? 'true' : 'false');
+        }
+    }
+    render() {
+        return (index.h("div", { key: '04210ff1a4689e32c72f73ee76a94cbe9867b0de', part: "base", id: this.componentId, class: {
+                dropdown: true,
+                'dropdown--open': this.open,
+            } }, index.h("span", { key: '9eb3c0e703b08734e9458b25021c0844d255ec6e', part: "trigger", class: "dropdown__trigger", ref: (el) => (this.trigger = el), onClick: this.handleTriggerClick, onKeyDown: this.handleTriggerKeyDown, onKeyUp: this.handleTriggerKeyUp }, index.h("slot", { key: '5cec1b43f07f830dfdebb3a71eb56f3233a539c4', name: "trigger", ref: (el) => (this.triggerSlot = el), onSlotchange: this.handleTriggerSlotChange })), index.h("div", { key: '8761367cfff9b66fdd4a7733f1c59440a507178b', ref: (el) => (this.positioner = el), class: {
+                dropdown__positioner: true,
+                dropdown__positioner__filtered: (this.filter || this.asyncFilter) && !this.hoist,
+            } }, index.h("div", { key: '2ab6c7166cea3892e429db21f3b56e7a81e94735', ref: (el) => (this.panel = el), part: "panel", class: "dropdown__panel", role: "menu", "aria-hidden": this.open ? 'false' : 'true', "aria-labelledby": this.componentId }, this.filterEnabled && (index.h("six-input", { key: 'f7425daad22c1a756dfda4ecefa6293ac5cdcca5', class: {
+                filter: true,
+                'filter-hidden': !this.open,
+            }, "dropdown-search": true, "aria-hidden": this.open ? 'false' : 'true', ref: (el) => (this.filterInputElement = el), placeholder: this.filterPlaceholder }, index.h("six-icon", { key: '6416f4e28bc437c18b1cff0e0a9eaa54c9aba3d5', class: "filter__icon", slot: "suffix", size: "small" }, "search"))), index.h("div", { key: '479140f2107baad72960b415bd69d9ac80bb6f64', class: {
+                dropdown__panel__scroll: true,
+                'dropdown__panel__scroll--virtual': this.virtualScroll,
+            }, onScroll: this.handleDropdownScroll, ref: (el) => (this.scrollPanel = el) }, index.h("slot", { key: '539cda534eb5ef042526b66487bec3d22c89fdd7', ref: (el) => (this.panelSlot = el) }), this.options.length > 0 && (index.h("six-menu", { key: '6294182636491e13514380d9516f904f8a9b2204', part: "menu", items: this.renderedOptions, virtualScroll: this.virtualScroll }))), index.h("slot", { key: '9029f9f9a69d2b6fd19b36755ab9771181a7d1c6', name: "dropdown-footer" })))));
+    }
+    get host() { return index.getElement(this); }
+    static get watchers() { return {
+        "open": ["handleOpenChange"],
+        "distance": ["handlePopoverOptionsChange"],
+        "hoist": ["handlePopoverOptionsChange"],
+        "placement": ["handlePopoverOptionsChange"],
+        "skidding": ["handlePopoverOptionsChange"],
+        "options": ["handleOptionsChange"],
+        "virtualScroll": ["handleOptionsChange"]
+    }; }
+};
+function isSixMenu(el) {
+    return (el === null || el === void 0 ? void 0 : el.tagName.toLowerCase()) === 'six-menu';
+}
+function isSixMenuItem(el) {
+    return (el === null || el === void 0 ? void 0 : el.tagName.toLowerCase()) === 'six-menu-item';
+}
+function isSelectionContainer(el) {
+    var _a;
+    return ((_a = el === null || el === void 0 ? void 0 : el.getAttribute('class')) === null || _a === void 0 ? void 0 : _a.includes('selection-container')) || false;
+}
+async function containsFilterTerm(menuItem, lowerCaseFilterTerm) {
+    return (menuItem.value.toLowerCase().includes(lowerCaseFilterTerm) ||
+        (await menuItem.getTextLabel()).toLowerCase().includes(lowerCaseFilterTerm));
+}
+SixDropdown.style = sixDropdownCss;
+
+const sixMenuCss = ":host{position:relative;box-sizing:border-box}:host *,:host *:before,:host *:after{box-sizing:border-box}.sr-only{clip:rect(0 0 0 0);clip-path:inset(50%);height:1px;overflow:hidden;position:absolute;white-space:nowrap;width:1px}:host{display:block}.menu{padding:var(--six-spacing-xx-small) 0;border:none;box-shadow:var(--six-shadow-small);overflow-y:auto;overflow-x:hidden}.menu:focus{outline:none}.no-shadow{box-shadow:none}";
+
+const isFocusedMenuItem = (menuItem) => { var _a, _b, _c; return (_c = (_b = (_a = menuItem === null || menuItem === void 0 ? void 0 : menuItem.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.menu-item')) === null || _b === void 0 ? void 0 : _b.classList) === null || _c === void 0 ? void 0 : _c.contains('menu-item--focused'); };
+const isSIXMenuItemElement = (el) => (el === null || el === void 0 ? void 0 : el.tagName.toLowerCase()) === 'six-menu-item';
+const mapToMenuItem = ({ value, label }) => (index.h("six-menu-item", { key: value, value: value }, label));
+const DEFAULT_NUMBER_OF_ITEMS_SHOWN_FOR_VIRTUAL_SCROLLING = 5;
+const DEFAULT_SIX_MENU_ITEM_HEIGHT_FOR_VIRTUAL_SCROLLING = 48;
+const DEFAULT_SIX_MENU_ITEM_HEIGHT = 64;
+const SixMenu = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.sixMenuItemSelected = index.createEvent(this, "six-menu-item-selected");
+        this.eventListeners = new eventListeners.EventListeners();
+        this.typeToSelectString = '';
+        /** Set to true to remove the box-shadow */
+        this.removeBoxShadow = false;
+        /** Set the options to be shown in the dropdown */
+        this.items = null;
+        /** Defines whether the menu list will be rendered virtually i.e. only the elements actually shown (and a couple around)
+         *  are actually rendered in the DOM. If you use virtual scrolling pass the elements via prop instead of via slot. */
+        this.virtualScroll = false;
+        /**
+         * Used for virtual scrolling
+         * Define how many items should be rendered in the DOM when using virtual scrolling
+         */
+        this.itemSize = 10;
+        /**
+         * Used for virtual scrolling
+         * Define the debounce for listening on scrolling changes in milliseconds.
+         * The lower the number the more sensitive the component reacts to scrolling changes.
+         */
+        this.scrollingDebounce = 15;
+        /**
+         * Internal: Disables handling of key presses.
+         */
+        this.disableKeyboardHandling = false;
+        /**
+         * Used to calculate which items should be rendered in the DOM
+         */
+        this.scrollingIndex = 0;
+        // set a default item height, this variable will be updated with the real value after the first render.
+        // However, it's necessary to have a default value because we can only fetch the proper height after the first render
+        this.sixMenuItemHeight = this.virtualScroll
+            ? DEFAULT_SIX_MENU_ITEM_HEIGHT_FOR_VIRTUAL_SCROLLING
+            : DEFAULT_SIX_MENU_ITEM_HEIGHT;
+        this.handleScrolling = () => {
+            if (this.menuWrapper == null)
+                return;
+            // for performance improvements we only update the DOM if the scrollRatio change "enough"
+            this.scrollingIndex = Math.floor(this.menuWrapper.scrollTop / this.sixMenuItemHeight);
+        };
+    }
+    connectedCallback() {
+        this.handleClick = this.handleClick.bind(this);
+        this.handleKeyDown = this.handleKeyDown.bind(this);
+    }
+    componentWillLoad() {
+        if (this.items === null) {
+            return;
+        }
+    }
+    componentDidLoad() {
+        this.setupForVirtualScrollingAfterRendering();
+    }
+    disconnectedCallback() {
+        this.eventListeners.removeAll();
+    }
+    /**
+     * Initiates type-to-select logic, which automatically selects an option based on what the user is currently typing.
+     * The key passed will be appended to the internal query and the selection will be updated. After a brief period, the
+     * internal query is cleared automatically. This method is intended to be used with the keydown event. Useful for
+     * enabling type-to-select when the menu doesn't have focus.
+     */
+    async typeToSelect(key) {
+        var _a;
+        clearTimeout(this.typeToSelectTimeout);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.typeToSelectTimeout = setTimeout(() => (this.typeToSelectString = ''), 750);
+        this.typeToSelectString += key.toLowerCase();
+        const items = this.getItems();
+        for (const item of items) {
+            const slot$1 = (_a = item.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('slot:not([name])');
+            const label = slot.getTextContent(slot$1).toLowerCase().trim();
+            if (label.substring(0, this.typeToSelectString.length) === this.typeToSelectString) {
+                item.setFocus();
+                break;
+            }
+        }
+    }
+    getItemsShown() {
+        var _a;
+        const defaultItemsShown = this.virtualScroll ? DEFAULT_NUMBER_OF_ITEMS_SHOWN_FOR_VIRTUAL_SCROLLING : 0;
+        if (this.items && this.items.length === 1) {
+            return 0;
+        }
+        return (_a = this.itemsShown) !== null && _a !== void 0 ? _a : defaultItemsShown;
+    }
+    setupForVirtualScrollingAfterRendering() {
+        var _a, _b;
+        if (!this.virtualScroll || this.menuWrapper == null)
+            return;
+        this.eventListeners.add(this.menuWrapper, 'scroll', executionControl.debounce(this.handleScrolling, this.scrollingDebounce));
+        // set menu height to proper height once the item is rendered.
+        const menuItemHeight = (_b = (_a = this.menu) === null || _a === void 0 ? void 0 : _a.querySelector('six-menu-item')) === null || _b === void 0 ? void 0 : _b.clientHeight;
+        if (menuItemHeight != null && menuItemHeight > 0) {
+            this.sixMenuItemHeight = menuItemHeight;
+        }
+    }
+    getItems() {
+        if (this.menu == null)
+            return [];
+        if (this.items != null) {
+            return this.items.map(mapToMenuItem);
+        }
+        const slot = this.menu.querySelector('slot');
+        if (slot == null)
+            return [];
+        return [...slot.assignedElements({ flatten: true })].filter((el) => isSIXMenuItemElement(el) && !el.disabled);
+    }
+    getActiveItemIndex() {
+        const items = this.getItems();
+        const selectedItem = this.getActiveItem();
+        if (selectedItem != null) {
+            const itemIndex = items.indexOf(selectedItem);
+            if (itemIndex > -1) {
+                return itemIndex;
+            }
+        }
+        const sixMenuItems = this.extractItemsFromDOM();
+        return sixMenuItems.findIndex(isFocusedMenuItem);
+    }
+    getActiveItem() {
+        var _a;
+        const activeElement = this.getItems().find((i) => i === document.activeElement);
+        if (activeElement != null) {
+            return activeElement;
+        }
+        return (_a = this.extractItemsFromDOM()) === null || _a === void 0 ? void 0 : _a.find(isFocusedMenuItem);
+    }
+    extractItemsFromDOM() {
+        var _a, _b;
+        return Array.from((_b = (_a = this.host.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelectorAll('six-menu-item')) !== null && _b !== void 0 ? _b : []);
+    }
+    setActiveItem(item) {
+        item === null || item === void 0 ? void 0 : item.setFocus();
+    }
+    handleClick(event) {
+        const target = event.target;
+        const clickedItem = target.closest('six-menu-item');
+        if (clickedItem && !clickedItem.disabled) {
+            this.sixMenuItemSelected.emit({ name: clickedItem.value, item: clickedItem });
+        }
+    }
+    handleKeyDown(event) {
+        if (this.disableKeyboardHandling) {
+            return;
+        }
+        // Make a selection when pressing enter
+        if (event.key === 'Enter') {
+            const activeItem = this.getActiveItem();
+            event.preventDefault();
+            if (activeItem != null) {
+                this.sixMenuItemSelected.emit({ name: activeItem.value, item: activeItem });
+            }
+        }
+        // Prevent scrolling when space is pressed
+        if (event.key === ' ') {
+            event.preventDefault();
+        }
+        // Move the selection when pressing down or up
+        if (['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) {
+            const items = this.items === null ? this.getItems() : this.extractItemsFromDOM();
+            let indexOfActiveItem = this.getActiveItemIndex();
+            if (items.length > 0) {
+                event.preventDefault();
+                if (event.key === 'ArrowDown') {
+                    indexOfActiveItem++;
+                }
+                else if (event.key === 'ArrowUp') {
+                    indexOfActiveItem--;
+                }
+                else if (event.key === 'Home') {
+                    indexOfActiveItem = 0;
+                }
+                else if (event.key === 'End') {
+                    indexOfActiveItem = items.length - 1;
+                }
+                if (indexOfActiveItem < 0)
+                    indexOfActiveItem = 0;
+                if (indexOfActiveItem > items.length - 1)
+                    indexOfActiveItem = items.length - 1;
+                this.setActiveItem(items[indexOfActiveItem]);
+                return;
+            }
+        }
+        void this.typeToSelect(event.key);
+    }
+    getMenuWrapperStyle() {
+        var _a;
+        const styles = {};
+        if (this.getItemsShown() > 0) {
+            // calculate the proper height to show the correct number of items
+            styles.height = `${((_a = this.getItemsShown()) !== null && _a !== void 0 ? _a : 0) * this.sixMenuItemHeight}px`;
+        }
+        else if (this.items && this.items.length === 1) {
+            styles.height = 'auto';
+        }
+        return Object.assign({}, styles);
+    }
+    getMenuContainerStyle() {
+        const styles = {};
+        if (this.virtualScroll) {
+            // calculate height of content are if all items would be rendered so the scrollbar has the proper size
+            styles.transform = `translateY(${this.sixMenuItemHeight * this.scrollingIndex}px)`;
+        }
+        return Object.assign({}, styles);
+    }
+    getScrollbarGhostStyle() {
+        const styles = {};
+        if (this.virtualScroll && this.items !== null && this.items.length > 1) {
+            styles.height = `${this.items.length * this.sixMenuItemHeight - this.itemSize * this.sixMenuItemHeight}px`;
+        }
+        return Object.assign({}, styles);
+    }
+    renderItems() {
+        if (this.items === undefined || this.items === null) {
+            return;
+        }
+        if (!this.virtualScroll) {
+            return this.items.map(mapToMenuItem);
+        }
+        return this.items
+            .slice(this.scrollingIndex, Math.min(this.items.length, this.itemSize + this.scrollingIndex))
+            .map(({ value, label }) => (index.h("six-menu-item", { checkType: "check", key: value, value: value }, label)));
+    }
+    render() {
+        return (index.h("div", { key: 'a346d393b279517ec252289e173e1d2e1ac82147', ref: (el) => (this.menuWrapper = el), style: this.getMenuWrapperStyle(), part: "wrapper", class: {
+                menu: true,
+                '.no-shadow': this.removeBoxShadow,
+            } }, index.h("div", { key: 'eeca9d33ecede486adc958510b2bc7028517a79a', ref: (el) => (this.menu = el), part: "base", role: "menu", onClick: this.handleClick, onKeyDown: this.handleKeyDown, tabIndex: 0, style: this.getMenuContainerStyle() }, index.h("slot", { key: 'c46d98b34ddaec7d041ee2ad4aa40a048a93cc80' }), this.renderItems()), this.virtualScroll && index.h("div", { key: '535cf4f968da60291f420da2722fc1692c0c064a', style: this.getScrollbarGhostStyle() })));
+    }
+    get host() { return index.getElement(this); }
+};
+SixMenu.style = sixMenuCss;
+
+exports.six_dropdown = SixDropdown;
+exports.six_menu = SixMenu;
+//# sourceMappingURL=six-dropdown.six-menu.entry.cjs.js.map
+
+//# sourceMappingURL=six-dropdown_2.cjs.entry.js.map