@skyux/popovers 8.7.0 → 9.0.0-alpha.0

package/{esm2020 → esm2022}/lib/modules/dropdown/dropdown-button.component.mjs

@@ -4,11 +4,11 @@ import * as i0 from "@angular/core";
  * Specifies the button for the dropdown menu.
  */
 export class SkyDropdownButtonComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDropdownButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyDropdownButtonComponent, selector: "sky-dropdown-button", ngImport: i0, template: "<ng-content></ng-content>\n" }); }
 }
-SkyDropdownButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyDropdownButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-SkyDropdownButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: SkyDropdownButtonComponent, selector: "sky-dropdown-button", ngImport: i0, template: "<ng-content></ng-content>\n" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyDropdownButtonComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDropdownButtonComponent, decorators: [{
             type: Component,
             args: [{ selector: 'sky-dropdown-button', template: "<ng-content></ng-content>\n" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTFDOztHQUVHO0FBS0gsTUFBTSxPQUFPLDBCQUEwQjs7dUhBQTFCLDBCQUEwQjsyR0FBMUIsMEJBQTBCLDJEQ1R2Qyw2QkFDQTsyRkRRYSwwQkFBMEI7a0JBSnRDLFNBQVM7K0JBQ0UscUJBQXFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogU3BlY2lmaWVzIHRoZSBidXR0b24gZm9yIHRoZSBkcm9wZG93biBtZW51LlxuICovXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdza3ktZHJvcGRvd24tYnV0dG9uJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2Ryb3Bkb3duLWJ1dHRvbi5jb21wb25lbnQuaHRtbCcsXG59KVxuZXhwb3J0IGNsYXNzIFNreURyb3Bkb3duQnV0dG9uQ29tcG9uZW50IHt9XG4iLCI8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTFDOztHQUVHO0FBS0gsTUFBTSxPQUFPLDBCQUEwQjs4R0FBMUIsMEJBQTBCO2tHQUExQiwwQkFBMEIsMkRDVHZDLDZCQUNBOzsyRkRRYSwwQkFBMEI7a0JBSnRDLFNBQVM7K0JBQ0UscUJBQXFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogU3BlY2lmaWVzIHRoZSBidXR0b24gZm9yIHRoZSBkcm9wZG93biBtZW51LlxuICovXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdza3ktZHJvcGRvd24tYnV0dG9uJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2Ryb3Bkb3duLWJ1dHRvbi5jb21wb25lbnQuaHRtbCcsXG59KVxuZXhwb3J0IGNsYXNzIFNreURyb3Bkb3duQnV0dG9uQ29tcG9uZW50IHt9XG4iLCI8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4iXX0=

package/esm2022/lib/modules/dropdown/dropdown-item.component.mjs

@@ -0,0 +1,68 @@
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Specifies the items to display on the dropdown menu.
+ */
+export class SkyDropdownItemComponent {
+    /**
+     * The ARIA role for the dropdown menu item
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility)
+     * by indicating how the item functions and what it controls. For information about
+     * how an ARIA role indicates what an item represents on a web page, see the
+     * [WAI-ARIA roles model](https://www.w3.org/WAI/PF/aria/#roles).
+     * @default "menuitem"
+     */
+    set ariaRole(value) {
+        this.#_ariaRole = value ?? 'menuitem';
+    }
+    get ariaRole() {
+        return this.#_ariaRole;
+    }
+    #_ariaRole;
+    #changeDetector;
+    #renderer;
+    constructor(elementRef, changeDetector, renderer) {
+        this.elementRef = elementRef;
+        this.isActive = false;
+        this.#_ariaRole = 'menuitem';
+        this.#changeDetector = changeDetector;
+        this.#renderer = renderer;
+    }
+    ngAfterViewInit() {
+        // Make sure anchor elements are tab-able.
+        const buttonElement = this.#getButtonElement();
+        /* istanbul ignore else */
+        if (buttonElement) {
+            this.#renderer.setAttribute(buttonElement, 'tabIndex', '0');
+        }
+        this.#changeDetector.detectChanges();
+    }
+    focusElement(enableNativeFocus) {
+        this.isActive = true;
+        if (enableNativeFocus) {
+            this.#getButtonElement()?.focus();
+        }
+        this.#changeDetector.detectChanges();
+    }
+    isFocusable() {
+        const isFocusable = this.#getButtonElement()?.getAttribute('disabled') === null;
+        return isFocusable;
+    }
+    resetState() {
+        this.isActive = false;
+        this.#changeDetector.markForCheck();
+    }
+    #getButtonElement() {
+        return this.elementRef.nativeElement.querySelector('button,a');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDropdownItemComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyDropdownItemComponent, selector: "sky-dropdown-item", inputs: { ariaRole: "ariaRole" }, ngImport: i0, template: "<div\n  class=\"sky-dropdown-item\"\n  [attr.role]=\"ariaRole\"\n  [ngClass]=\"{\n    'sky-dropdown-item-active': isActive\n  }\"\n>\n  <ng-content> </ng-content>\n</div>\n", styles: [".sky-dropdown-item{background-color:transparent;border:none;display:block;margin:4px;min-width:160px;text-align:left}.sky-dropdown-item.sky-dropdown-item-active a,.sky-dropdown-item.sky-dropdown-item-active button,.sky-dropdown-item:hover a,.sky-dropdown-item:hover button{background-color:#eeeeef}.sky-dropdown-item button[disabled],.sky-dropdown-item a[disabled]{cursor:default}.sky-dropdown-item button[disabled]:hover,.sky-dropdown-item a[disabled]:hover{background-color:transparent}.sky-dropdown-item>a,.sky-dropdown-item>button{background-color:transparent;border:none;color:#212327;cursor:pointer;display:block;padding:3px 20px;text-align:left;width:100%}.sky-dropdown-item>a:hover,.sky-dropdown-item>button:hover{text-decoration:none}.sky-dropdown-item>a[disabled],.sky-dropdown-item>button[disabled]{color:#686c73}.sky-dropdown-item>a[disabled]:hover,.sky-dropdown-item>button[disabled]:hover{cursor:default}.sky-theme-modern .sky-dropdown-item{margin:0}.sky-theme-modern .sky-dropdown-item.sky-dropdown-item-active,.sky-theme-modern .sky-dropdown-item:hover{background-color:transparent}.sky-theme-modern .sky-dropdown-item>a,.sky-theme-modern .sky-dropdown-item>button{padding:10px 20px;border-radius:6px;transition:box-shadow .15s}.sky-theme-modern .sky-dropdown-item>a:hover,.sky-theme-modern .sky-dropdown-item>button:hover{outline:solid 1px #1870B8;outline-offset:-1px}.sky-theme-modern .sky-dropdown-item>a:focus-visible,.sky-theme-modern .sky-dropdown-item>a:active,.sky-theme-modern .sky-dropdown-item>button:focus-visible,.sky-theme-modern .sky-dropdown-item>button:active{outline:solid 2px #1870B8;outline-offset:-2px}.sky-theme-modern .sky-dropdown-item>a:focus-visible:not(:active),.sky-theme-modern .sky-dropdown-item>button:focus-visible:not(:active){box-shadow:0 1px 8px #0000004d}.sky-theme-modern.sky-theme-mode-dark .sky-dropdown-item>a,.sky-theme-modern.sky-theme-mode-dark .sky-dropdown-item>button{color:#fbfcfe}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDropdownItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-dropdown-item', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<div\n  class=\"sky-dropdown-item\"\n  [attr.role]=\"ariaRole\"\n  [ngClass]=\"{\n    'sky-dropdown-item-active': isActive\n  }\"\n>\n  <ng-content> </ng-content>\n</div>\n", styles: [".sky-dropdown-item{background-color:transparent;border:none;display:block;margin:4px;min-width:160px;text-align:left}.sky-dropdown-item.sky-dropdown-item-active a,.sky-dropdown-item.sky-dropdown-item-active button,.sky-dropdown-item:hover a,.sky-dropdown-item:hover button{background-color:#eeeeef}.sky-dropdown-item button[disabled],.sky-dropdown-item a[disabled]{cursor:default}.sky-dropdown-item button[disabled]:hover,.sky-dropdown-item a[disabled]:hover{background-color:transparent}.sky-dropdown-item>a,.sky-dropdown-item>button{background-color:transparent;border:none;color:#212327;cursor:pointer;display:block;padding:3px 20px;text-align:left;width:100%}.sky-dropdown-item>a:hover,.sky-dropdown-item>button:hover{text-decoration:none}.sky-dropdown-item>a[disabled],.sky-dropdown-item>button[disabled]{color:#686c73}.sky-dropdown-item>a[disabled]:hover,.sky-dropdown-item>button[disabled]:hover{cursor:default}.sky-theme-modern .sky-dropdown-item{margin:0}.sky-theme-modern .sky-dropdown-item.sky-dropdown-item-active,.sky-theme-modern .sky-dropdown-item:hover{background-color:transparent}.sky-theme-modern .sky-dropdown-item>a,.sky-theme-modern .sky-dropdown-item>button{padding:10px 20px;border-radius:6px;transition:box-shadow .15s}.sky-theme-modern .sky-dropdown-item>a:hover,.sky-theme-modern .sky-dropdown-item>button:hover{outline:solid 1px #1870B8;outline-offset:-1px}.sky-theme-modern .sky-dropdown-item>a:focus-visible,.sky-theme-modern .sky-dropdown-item>a:active,.sky-theme-modern .sky-dropdown-item>button:focus-visible,.sky-theme-modern .sky-dropdown-item>button:active{outline:solid 2px #1870B8;outline-offset:-2px}.sky-theme-modern .sky-dropdown-item>a:focus-visible:not(:active),.sky-theme-modern .sky-dropdown-item>button:focus-visible:not(:active){box-shadow:0 1px 8px #0000004d}.sky-theme-modern.sky-theme-mode-dark .sky-dropdown-item>a,.sky-theme-modern.sky-theme-mode-dark .sky-dropdown-item>button{color:#fbfcfe}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }]; }, propDecorators: { ariaRole: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/dropdown/dropdown-menu.component.mjs

@@ -0,0 +1,314 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Optional, Output, ViewEncapsulation, } from '@angular/core';
+import { Subject, fromEvent as observableFromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyDropdownItemComponent } from './dropdown-item.component';
+import { SkyDropdownMessageType } from './types/dropdown-message-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./dropdown.component";
+let nextId = 0;
+/**
+ * Creates a menu that contains dropdown menu items.
+ *
+ */
+export class SkyDropdownMenuComponent {
+    /**
+     * The ARIA role for the dropdown menu
+     * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility)
+     * by indicating how the dropdown menu functions and what it controls. The dropdown button
+     * inherits this value to set its `aria-haspopup` property. For information
+     * about how an ARIA role indicates what an item represents on a web page, see the
+     * [WAI-ARIA roles model](https://www.w3.org/WAI/PF/aria/#roles).
+     * @default "menu"
+     */
+    set ariaRole(value) {
+        this.#_ariaRole = value ?? 'menu';
+    }
+    get ariaRole() {
+        return this.#_ariaRole;
+    }
+    /**
+     * Whether to use the browser's native focus function when users navigate through menu
+     * items with the keyboard. To disable the native focus function, set this property to `false`.
+     * For example, to let users interact with the dropdown menu but keep the keyboard focus on a
+     * different element, set this property to `false`.
+     * @default true
+     * @internal
+     */
+    set useNativeFocus(value) {
+        this.#_useNativeFocus = value ?? true;
+    }
+    get useNativeFocus() {
+        return this.#_useNativeFocus;
+    }
+    set menuIndex(value) {
+        if (value < 0) {
+            value = this.menuItems.length - 1;
+        }
+        if (value >= this.menuItems.length) {
+            value = 0;
+        }
+        this.#_menuIndex = value;
+    }
+    get menuIndex() {
+        return this.#_menuIndex;
+    }
+    #ngUnsubscribe;
+    #_ariaRole;
+    #_menuIndex;
+    #_useNativeFocus;
+    #changeDetector;
+    #elementRef;
+    #dropdownComponent;
+    constructor(changeDetector, elementRef, dropdownComponent) {
+        /**
+         * Fires when the dropdown menu's active index or selected item changes. This event provides an
+         * observable to emit changes, and the response is of
+         * the SkyDropdownMenuChange type.
+         * @internal
+         */
+        this.menuChanges = new EventEmitter();
+        this.dropdownMenuId = `sky-dropdown-menu-${++nextId}`;
+        this.#ngUnsubscribe = new Subject();
+        this.#_ariaRole = 'menu';
+        this.#_menuIndex = 0;
+        this.#_useNativeFocus = true;
+        this.#changeDetector = changeDetector;
+        this.#elementRef = elementRef;
+        this.#dropdownComponent = dropdownComponent;
+    }
+    ngAfterContentInit() {
+        /* istanbul ignore else */
+        if (this.#dropdownComponent) {
+            this.#dropdownComponent.menuId = this.dropdownMenuId;
+            this.#dropdownComponent.menuAriaRole = this.ariaRole;
+            this.#dropdownComponent.messageStream
+                ?.pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((message) => {
+                switch (message.type) {
+                    case SkyDropdownMessageType.Open:
+                    case SkyDropdownMessageType.Close:
+                        this.reset();
+                        break;
+                    case SkyDropdownMessageType.FocusFirstItem:
+                        this.focusFirstItem();
+                        break;
+                    case SkyDropdownMessageType.FocusNextItem:
+                        this.focusNextItem();
+                        break;
+                    case SkyDropdownMessageType.FocusPreviousItem:
+                        this.focusPreviousItem();
+                        break;
+                    case SkyDropdownMessageType.FocusLastItem:
+                        this.focusLastItem();
+                        break;
+                }
+            });
+            this.menuChanges
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((change) => {
+                // Close the dropdown when a menu item is selected.
+                if (change.selectedItem) {
+                    this.#sendMessage(SkyDropdownMessageType.Close);
+                    this.#sendMessage(SkyDropdownMessageType.FocusTriggerButton);
+                }
+                if (change.items) {
+                    // Update the popover style and position whenever the number of items changes.
+                    this.#sendMessage(SkyDropdownMessageType.Reposition);
+                }
+            });
+        }
+        // Reset dropdown whenever the menu items change.
+        this.menuItems.changes
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((items) => {
+            this.reset();
+            this.menuChanges.emit({
+                items: items.toArray(),
+            });
+        });
+        this.#addEventListeners();
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    focusFirstItem() {
+        if (!this.#hasFocusableItems()) {
+            return;
+        }
+        this.menuIndex = 0;
+        const firstItem = this.#getItemByIndex(this.menuIndex);
+        if (firstItem && firstItem.isFocusable()) {
+            this.#focusItem(firstItem);
+        }
+        else {
+            this.focusNextItem();
+        }
+    }
+    focusLastItem() {
+        if (!this.#hasFocusableItems()) {
+            return;
+        }
+        this.menuIndex = this.menuItems.length - 1;
+        const lastItem = this.#getItemByIndex(this.menuIndex);
+        if (lastItem && lastItem.isFocusable()) {
+            this.#focusItem(lastItem);
+        }
+        else {
+            this.focusPreviousItem();
+        }
+    }
+    focusPreviousItem() {
+        if (!this.#hasFocusableItems()) {
+            return;
+        }
+        this.menuIndex--;
+        const previousItem = this.#getItemByIndex(this.menuIndex);
+        if (previousItem && previousItem.isFocusable()) {
+            this.#focusItem(previousItem);
+        }
+        else {
+            this.focusPreviousItem();
+        }
+    }
+    focusNextItem() {
+        if (!this.#hasFocusableItems()) {
+            return;
+        }
+        this.menuIndex++;
+        const nextItem = this.#getItemByIndex(this.menuIndex);
+        if (nextItem && nextItem.isFocusable()) {
+            this.#focusItem(nextItem);
+        }
+        else {
+            this.focusNextItem();
+        }
+    }
+    reset() {
+        this.#_menuIndex = -1;
+        this.#resetItemsActiveState();
+        this.#changeDetector.markForCheck();
+    }
+    #resetItemsActiveState() {
+        this.menuItems.forEach((item) => {
+            item.resetState();
+        });
+    }
+    #focusItem(item) {
+        this.#resetItemsActiveState();
+        item.focusElement(this.useNativeFocus);
+        this.menuChanges.emit({
+            activeIndex: this.menuIndex,
+        });
+    }
+    #getItemByIndex(index) {
+        return this.menuItems.find((_, i) => i === index);
+    }
+    #selectItemByEventTarget(target) {
+        const selectedItem = this.menuItems.find((item, i) => {
+            const found = item.elementRef.nativeElement.contains(target);
+            if (found) {
+                this.menuIndex = i;
+                this.menuChanges.next({
+                    activeIndex: this.menuIndex,
+                });
+            }
+            return found;
+        });
+        /* istanbul ignore else */
+        if (selectedItem) {
+            this.menuChanges.next({
+                selectedItem,
+            });
+        }
+    }
+    #sendMessage(type) {
+        this.#dropdownComponent?.messageStream?.next({ type });
+    }
+    #addEventListeners() {
+        const dropdownMenuElement = this.#elementRef.nativeElement;
+        observableFromEvent(dropdownMenuElement, 'click')
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((event) => {
+            this.#selectItemByEventTarget(event.target);
+        });
+        observableFromEvent(dropdownMenuElement, 'keydown')
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((event) => {
+            const key = event.key.toLowerCase();
+            switch (key) {
+                case 'escape':
+                    this.#sendMessage(SkyDropdownMessageType.Close);
+                    this.#sendMessage(SkyDropdownMessageType.FocusTriggerButton);
+                    event.stopPropagation();
+                    event.preventDefault();
+                    break;
+                case 'arrowdown':
+                case 'down':
+                    this.focusNextItem();
+                    event.preventDefault();
+                    break;
+                case 'arrowup':
+                case 'up':
+                    this.focusPreviousItem();
+                    event.preventDefault();
+                    break;
+                case 'tab':
+                    if (this.#dropdownComponent?.dismissOnBlur) {
+                        this.#sendMessage(SkyDropdownMessageType.Close);
+                    }
+                    this.#sendMessage(SkyDropdownMessageType.FocusTriggerButton);
+                    break;
+            }
+        });
+        observableFromEvent(dropdownMenuElement, 'mouseenter')
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe(() => {
+            /* istanbul ignore else */
+            if (this.#dropdownComponent) {
+                this.#dropdownComponent.isMouseEnter = true;
+            }
+        });
+        observableFromEvent(dropdownMenuElement, 'mouseleave')
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe(() => {
+            /* istanbul ignore else */
+            if (this.#dropdownComponent) {
+                this.#dropdownComponent.isMouseEnter = false;
+                // Allow the dropdown component to set isMouseEnter before checking if the close action
+                // should be taken.
+                setTimeout(() => {
+                    if (this.#dropdownComponent &&
+                        this.#dropdownComponent.trigger === 'hover' &&
+                        this.#dropdownComponent.isMouseEnter === false) {
+                        this.#sendMessage(SkyDropdownMessageType.Close);
+                    }
+                });
+            }
+        });
+    }
+    #hasFocusableItems() {
+        const found = this.menuItems.find((item) => item.isFocusable());
+        return found !== undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDropdownMenuComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.SkyDropdownComponent, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyDropdownMenuComponent, selector: "sky-dropdown-menu", inputs: { ariaLabelledBy: "ariaLabelledBy", ariaRole: "ariaRole", useNativeFocus: "useNativeFocus" }, outputs: { menuChanges: "menuChanges" }, queries: [{ propertyName: "menuItems", predicate: SkyDropdownItemComponent, descendants: true }], ngImport: i0, template: "<div\n  class=\"sky-dropdown-menu sky-shadow sky-elevation-4\"\n  [attr.aria-labelledby]=\"ariaLabelledBy\"\n  [attr.role]=\"ariaRole\"\n  [id]=\"dropdownMenuId\"\n>\n  <ng-content> </ng-content>\n</div>\n", styles: [".sky-dropdown-menu{overflow-y:auto;overflow-x:hidden;min-height:35px;max-height:calc(50vh - 50px);display:flex;flex-direction:column;background-color:#fff}.sky-dropdown-menu button{overflow:hidden;text-overflow:ellipsis}.sky-theme-modern .sky-dropdown-menu{border-radius:6px;padding:10px 0}.sky-theme-modern.sky-theme-mode-dark .sky-dropdown-menu{background-color:#252a2e;color:#fff}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyDropdownMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-dropdown-menu', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<div\n  class=\"sky-dropdown-menu sky-shadow sky-elevation-4\"\n  [attr.aria-labelledby]=\"ariaLabelledBy\"\n  [attr.role]=\"ariaRole\"\n  [id]=\"dropdownMenuId\"\n>\n  <ng-content> </ng-content>\n</div>\n", styles: [".sky-dropdown-menu{overflow-y:auto;overflow-x:hidden;min-height:35px;max-height:calc(50vh - 50px);display:flex;flex-direction:column;background-color:#fff}.sky-dropdown-menu button{overflow:hidden;text-overflow:ellipsis}.sky-theme-modern .sky-dropdown-menu{border-radius:6px;padding:10px 0}.sky-theme-modern.sky-theme-mode-dark .sky-dropdown-menu{background-color:#252a2e;color:#fff}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.SkyDropdownComponent, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { ariaLabelledBy: [{
+                type: Input
+            }], ariaRole: [{
+                type: Input
+            }], useNativeFocus: [{
+                type: Input
+            }], menuChanges: [{
+                type: Output
+            }], menuItems: [{
+                type: ContentChildren,
+                args: [SkyDropdownItemComponent, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-menu.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/popovers/src/lib/modules/dropdown/dropdown-menu.component.ts","../../../../../../../../libs/components/popovers/src/lib/modules/dropdown/dropdown-menu.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  ViewEncapsulation,\n} from '@angular/core';\n\nimport { Subject, fromEvent as observableFromEvent } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyDropdownItemComponent } from './dropdown-item.component';\nimport { SkyDropdownComponent } from './dropdown.component';\nimport { SkyDropdownMenuChange } from './types/dropdown-menu-change';\nimport { SkyDropdownMessage } from './types/dropdown-message';\nimport { SkyDropdownMessageType } from './types/dropdown-message-type';\n\nlet nextId = 0;\n/**\n * Creates a menu that contains dropdown menu items.\n *\n */\n@Component({\n  selector: 'sky-dropdown-menu',\n  templateUrl: './dropdown-menu.component.html',\n  styleUrls: ['./dropdown-menu.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class SkyDropdownMenuComponent implements AfterContentInit, OnDestroy {\n  /**\n   * The HTML element ID of the element that labels\n   * the dropdown menu. This sets the dropdown menu's `aria-labelledby` attribute to provide a text equivalent for\n   * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).\n   * For more information about the `aria-labelledby` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-labelledby).\n   */\n  @Input()\n  public ariaLabelledBy: string | undefined;\n\n  /**\n   * The ARIA role for the dropdown menu\n   * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility)\n   * by indicating how the dropdown menu functions and what it controls. The dropdown button\n   * inherits this value to set its `aria-haspopup` property. For information\n   * about how an ARIA role indicates what an item represents on a web page, see the\n   * [WAI-ARIA roles model](https://www.w3.org/WAI/PF/aria/#roles).\n   * @default \"menu\"\n   */\n  @Input()\n  public set ariaRole(value: string | undefined) {\n    this.#_ariaRole = value ?? 'menu';\n  }\n\n  public get ariaRole(): string {\n    return this.#_ariaRole;\n  }\n\n  /**\n   * Whether to use the browser's native focus function when users navigate through menu\n   * items with the keyboard. To disable the native focus function, set this property to `false`.\n   * For example, to let users interact with the dropdown menu but keep the keyboard focus on a\n   * different element, set this property to `false`.\n   * @default true\n   * @internal\n   */\n  @Input()\n  public set useNativeFocus(value: boolean | undefined) {\n    this.#_useNativeFocus = value ?? true;\n  }\n\n  public get useNativeFocus(): boolean {\n    return this.#_useNativeFocus;\n  }\n\n  /**\n   * Fires when the dropdown menu's active index or selected item changes. This event provides an\n   * observable to emit changes, and the response is of\n   * the SkyDropdownMenuChange type.\n   * @internal\n   */\n  @Output()\n  public menuChanges = new EventEmitter<SkyDropdownMenuChange>();\n\n  public dropdownMenuId = `sky-dropdown-menu-${++nextId}`;\n\n  public set menuIndex(value: number) {\n    if (value < 0) {\n      value = this.menuItems.length - 1;\n    }\n\n    if (value >= this.menuItems.length) {\n      value = 0;\n    }\n\n    this.#_menuIndex = value;\n  }\n\n  public get menuIndex(): number {\n    return this.#_menuIndex;\n  }\n\n  @ContentChildren(SkyDropdownItemComponent, { descendants: true })\n  public menuItems!: QueryList<SkyDropdownItemComponent>;\n\n  #ngUnsubscribe = new Subject<void>();\n\n  #_ariaRole = 'menu';\n\n  #_menuIndex = 0;\n\n  #_useNativeFocus = true;\n\n  #changeDetector: ChangeDetectorRef;\n  #elementRef: ElementRef;\n  #dropdownComponent: SkyDropdownComponent | undefined;\n\n  constructor(\n    changeDetector: ChangeDetectorRef,\n    elementRef: ElementRef,\n    @Optional() dropdownComponent?: SkyDropdownComponent\n  ) {\n    this.#changeDetector = changeDetector;\n    this.#elementRef = elementRef;\n    this.#dropdownComponent = dropdownComponent;\n  }\n\n  public ngAfterContentInit(): void {\n    /* istanbul ignore else */\n    if (this.#dropdownComponent) {\n      this.#dropdownComponent.menuId = this.dropdownMenuId;\n      this.#dropdownComponent.menuAriaRole = this.ariaRole;\n\n      this.#dropdownComponent.messageStream\n        ?.pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((message: SkyDropdownMessage) => {\n          switch (message.type) {\n            case SkyDropdownMessageType.Open:\n            case SkyDropdownMessageType.Close:\n              this.reset();\n              break;\n\n            case SkyDropdownMessageType.FocusFirstItem:\n              this.focusFirstItem();\n              break;\n\n            case SkyDropdownMessageType.FocusNextItem:\n              this.focusNextItem();\n              break;\n\n            case SkyDropdownMessageType.FocusPreviousItem:\n              this.focusPreviousItem();\n              break;\n\n            case SkyDropdownMessageType.FocusLastItem:\n              this.focusLastItem();\n              break;\n          }\n        });\n\n      this.menuChanges\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((change: SkyDropdownMenuChange) => {\n          // Close the dropdown when a menu item is selected.\n          if (change.selectedItem) {\n            this.#sendMessage(SkyDropdownMessageType.Close);\n            this.#sendMessage(SkyDropdownMessageType.FocusTriggerButton);\n          }\n\n          if (change.items) {\n            // Update the popover style and position whenever the number of items changes.\n            this.#sendMessage(SkyDropdownMessageType.Reposition);\n          }\n        });\n    }\n\n    // Reset dropdown whenever the menu items change.\n    this.menuItems.changes\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((items: QueryList<SkyDropdownItemComponent>) => {\n        this.reset();\n        this.menuChanges.emit({\n          items: items.toArray(),\n        });\n      });\n\n    this.#addEventListeners();\n  }\n\n  public ngOnDestroy(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n  }\n\n  public focusFirstItem(): void {\n    if (!this.#hasFocusableItems()) {\n      return;\n    }\n\n    this.menuIndex = 0;\n\n    const firstItem = this.#getItemByIndex(this.menuIndex);\n    if (firstItem && firstItem.isFocusable()) {\n      this.#focusItem(firstItem);\n    } else {\n      this.focusNextItem();\n    }\n  }\n\n  public focusLastItem(): void {\n    if (!this.#hasFocusableItems()) {\n      return;\n    }\n\n    this.menuIndex = this.menuItems.length - 1;\n\n    const lastItem = this.#getItemByIndex(this.menuIndex);\n    if (lastItem && lastItem.isFocusable()) {\n      this.#focusItem(lastItem);\n    } else {\n      this.focusPreviousItem();\n    }\n  }\n\n  public focusPreviousItem(): void {\n    if (!this.#hasFocusableItems()) {\n      return;\n    }\n\n    this.menuIndex--;\n\n    const previousItem = this.#getItemByIndex(this.menuIndex);\n    if (previousItem && previousItem.isFocusable()) {\n      this.#focusItem(previousItem);\n    } else {\n      this.focusPreviousItem();\n    }\n  }\n\n  public focusNextItem() {\n    if (!this.#hasFocusableItems()) {\n      return;\n    }\n\n    this.menuIndex++;\n\n    const nextItem = this.#getItemByIndex(this.menuIndex);\n    if (nextItem && nextItem.isFocusable()) {\n      this.#focusItem(nextItem);\n    } else {\n      this.focusNextItem();\n    }\n  }\n\n  public reset(): void {\n    this.#_menuIndex = -1;\n    this.#resetItemsActiveState();\n    this.#changeDetector.markForCheck();\n  }\n\n  #resetItemsActiveState() {\n    this.menuItems.forEach((item: SkyDropdownItemComponent) => {\n      item.resetState();\n    });\n  }\n\n  #focusItem(item: SkyDropdownItemComponent): void {\n    this.#resetItemsActiveState();\n    item.focusElement(this.useNativeFocus);\n    this.menuChanges.emit({\n      activeIndex: this.menuIndex,\n    });\n  }\n\n  #getItemByIndex(index: number): SkyDropdownItemComponent | undefined {\n    return this.menuItems.find((_, i) => i === index);\n  }\n\n  #selectItemByEventTarget(target: EventTarget): void {\n    const selectedItem = this.menuItems.find(\n      (item: SkyDropdownItemComponent, i: number) => {\n        const found = item.elementRef.nativeElement.contains(target);\n\n        if (found) {\n          this.menuIndex = i;\n          this.menuChanges.next({\n            activeIndex: this.menuIndex,\n          });\n        }\n\n        return found;\n      }\n    );\n\n    /* istanbul ignore else */\n    if (selectedItem) {\n      this.menuChanges.next({\n        selectedItem,\n      });\n    }\n  }\n\n  #sendMessage(type: SkyDropdownMessageType): void {\n    this.#dropdownComponent?.messageStream?.next({ type });\n  }\n\n  #addEventListeners(): void {\n    const dropdownMenuElement = this.#elementRef.nativeElement;\n\n    observableFromEvent<MouseEvent>(dropdownMenuElement, 'click')\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((event) => {\n        this.#selectItemByEventTarget(event.target as EventTarget);\n      });\n\n    observableFromEvent<KeyboardEvent>(dropdownMenuElement, 'keydown')\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((event) => {\n        const key = event.key.toLowerCase();\n\n        switch (key) {\n          case 'escape':\n            this.#sendMessage(SkyDropdownMessageType.Close);\n            this.#sendMessage(SkyDropdownMessageType.FocusTriggerButton);\n            event.stopPropagation();\n            event.preventDefault();\n            break;\n\n          case 'arrowdown':\n          case 'down':\n            this.focusNextItem();\n            event.preventDefault();\n            break;\n\n          case 'arrowup':\n          case 'up':\n            this.focusPreviousItem();\n            event.preventDefault();\n            break;\n\n          case 'tab':\n            if (this.#dropdownComponent?.dismissOnBlur) {\n              this.#sendMessage(SkyDropdownMessageType.Close);\n            }\n            this.#sendMessage(SkyDropdownMessageType.FocusTriggerButton);\n            break;\n        }\n      });\n\n    observableFromEvent(dropdownMenuElement, 'mouseenter')\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe(() => {\n        /* istanbul ignore else */\n        if (this.#dropdownComponent) {\n          this.#dropdownComponent.isMouseEnter = true;\n        }\n      });\n\n    observableFromEvent(dropdownMenuElement, 'mouseleave')\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe(() => {\n        /* istanbul ignore else */\n        if (this.#dropdownComponent) {\n          this.#dropdownComponent.isMouseEnter = false;\n          // Allow the dropdown component to set isMouseEnter before checking if the close action\n          // should be taken.\n          setTimeout(() => {\n            if (\n              this.#dropdownComponent &&\n              this.#dropdownComponent.trigger === 'hover' &&\n              this.#dropdownComponent.isMouseEnter === false\n            ) {\n              this.#sendMessage(SkyDropdownMessageType.Close);\n            }\n          });\n        }\n      });\n  }\n\n  #hasFocusableItems(): boolean {\n    const found = this.menuItems.find((item) => item.isFocusable());\n    return found !== undefined;\n  }\n}\n","<div\n  class=\"sky-dropdown-menu sky-shadow sky-elevation-4\"\n  [attr.aria-labelledby]=\"ariaLabelledBy\"\n  [attr.role]=\"ariaRole\"\n  [id]=\"dropdownMenuId\"\n>\n  <ng-content> </ng-content>\n</div>\n"]}