@skyux/popovers 5.7.1 → 6.0.0-beta.0

package/documentation.json

@@ -360,7 +360,7 @@
               "name": "NgModule"
             },
             "arguments": {
-              "obj": "{\n  declarations: [\n    SkyPopoverComponent,\n    SkyPopoverContentComponent,\n    SkyPopoverDirective,\n  ],\n  imports: [\n    CommonModule,\n    SkyAffixModule,\n    SkyIconModule,\n    SkyOverlayModule,\n    SkyPopoversResourcesModule,\n    SkyThemeModule,\n  ],\n  exports: [\n    SkyPopoverComponent,\n    SkyPopoverContentComponent,\n    SkyPopoverDirective,\n  ],\n  entryComponents: [SkyPopoverContentComponent],\n}"
+              "obj": "{\n  declarations: [\n    SkyPopoverComponent,\n    SkyPopoverContentComponent,\n    SkyPopoverDirective,\n  ],\n  imports: [\n    CommonModule,\n    SkyAffixModule,\n    SkyIconModule,\n    SkyOverlayModule,\n    SkyPopoversResourcesModule,\n    SkyThemeModule,\n  ],\n  exports: [\n    SkyPopoverComponent,\n    SkyPopoverContentComponent,\n    SkyPopoverDirective,\n  ],\n}"
             }
           }
         ],
@@ -377,7 +377,7 @@
         "sources": [
           {
             "fileName": "projects/popovers/src/modules/popover/popover.module.ts",
-            "line": 34,
+            "line": 33,
             "character": 13
           }
         ]

package/esm2020/index.mjs

@@ -0,0 +1,23 @@
+export * from './lib/modules/dropdown/types/dropdown-horizontal-alignment';
+export * from './lib/modules/dropdown/types/dropdown-menu-change';
+export * from './lib/modules/dropdown/types/dropdown-message';
+export * from './lib/modules/dropdown/types/dropdown-message-type';
+export * from './lib/modules/dropdown/types/dropdown-trigger-type';
+export * from './lib/modules/dropdown/dropdown.module';
+export * from './lib/modules/popover/popover.module';
+export * from './lib/modules/popover/types/popover-alignment';
+export * from './lib/modules/popover/types/popover-message';
+export * from './lib/modules/popover/types/popover-message-type';
+export * from './lib/modules/popover/types/popover-placement';
+export * from './lib/modules/popover/types/popover-position';
+export * from './lib/modules/popover/types/popover-trigger';
+// Components and directives must be exported to support Angular's "partial" Ivy compiler.
+// Obscure names are used to indicate types are not part of the public API.
+export { SkyDropdownItemComponent as λ1 } from './lib/modules/dropdown/dropdown-item.component';
+export { SkyDropdownButtonComponent as λ2 } from './lib/modules/dropdown/dropdown-button.component';
+export { SkyDropdownComponent as λ3 } from './lib/modules/dropdown/dropdown.component';
+export { SkyDropdownMenuComponent as λ4 } from './lib/modules/dropdown/dropdown-menu.component';
+export { SkyPopoverContentComponent as λ5 } from './lib/modules/popover/popover-content.component';
+export { SkyPopoverComponent as λ6 } from './lib/modules/popover/popover.component';
+export { SkyPopoverDirective as λ7 } from './lib/modules/popover/popover.directive';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/dropdown/dropdown-button.component.mjs

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SkyDropdownButtonComponent {
+}
+SkyDropdownButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDropdownButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SkyDropdownButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: SkyDropdownButtonComponent, selector: "sky-dropdown-button", ngImport: i0, template: "<ng-content></ng-content>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDropdownButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-dropdown-button', template: "<ng-content></ng-content>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tYnV0dG9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTTFDLE1BQU0sT0FBTywwQkFBMEI7O3VIQUExQiwwQkFBMEI7MkdBQTFCLDBCQUEwQiwyRENOdkMsNkJBQ0E7MkZES2EsMEJBQTBCO2tCQUp0QyxTQUFTOytCQUNFLHFCQUFxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdza3ktZHJvcGRvd24tYnV0dG9uJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2Ryb3Bkb3duLWJ1dHRvbi5jb21wb25lbnQuaHRtbCcsXG59KVxuZXhwb3J0IGNsYXNzIFNreURyb3Bkb3duQnV0dG9uQ29tcG9uZW50IHt9XG4iLCI8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4iXX0=

package/esm2020/lib/modules/dropdown/dropdown-extensions.mjs

@@ -0,0 +1,14 @@
+export function parseAffixHorizontalAlignment(alignment) {
+    switch (alignment) {
+        case 'center':
+            return 'center';
+        case 'left':
+            return 'left';
+        case 'right':
+            return 'right';
+        /* istanbul ignore next */
+        default:
+            throw `SkyAffixHorizontalAlignment does not have a matching value for '${alignment}'!`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24tZXh0ZW5zaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9wb3BvdmVycy9zcmMvbGliL21vZHVsZXMvZHJvcGRvd24vZHJvcGRvd24tZXh0ZW5zaW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLFVBQVUsNkJBQTZCLENBQzNDLFNBQXlDO0lBRXpDLFFBQVEsU0FBUyxFQUFFO1FBQ2pCLEtBQUssUUFBUTtZQUNYLE9BQU8sUUFBUSxDQUFDO1FBQ2xCLEtBQUssTUFBTTtZQUNULE9BQU8sTUFBTSxDQUFDO1FBQ2hCLEtBQUssT0FBTztZQUNWLE9BQU8sT0FBTyxDQUFDO1FBQ2pCLDBCQUEwQjtRQUMxQjtZQUNFLE1BQU0sbUVBQW1FLFNBQVMsSUFBSSxDQUFDO0tBQzFGO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNreUFmZml4SG9yaXpvbnRhbEFsaWdubWVudCB9IGZyb20gJ0Bza3l1eC9jb3JlJztcblxuaW1wb3J0IHsgU2t5RHJvcGRvd25Ib3Jpem9udGFsQWxpZ25tZW50IH0gZnJvbSAnLi90eXBlcy9kcm9wZG93bi1ob3Jpem9udGFsLWFsaWdubWVudCc7XG5cbmV4cG9ydCBmdW5jdGlvbiBwYXJzZUFmZml4SG9yaXpvbnRhbEFsaWdubWVudChcbiAgYWxpZ25tZW50OiBTa3lEcm9wZG93bkhvcml6b250YWxBbGlnbm1lbnRcbik6IFNreUFmZml4SG9yaXpvbnRhbEFsaWdubWVudCB7XG4gIHN3aXRjaCAoYWxpZ25tZW50KSB7XG4gICAgY2FzZSAnY2VudGVyJzpcbiAgICAgIHJldHVybiAnY2VudGVyJztcbiAgICBjYXNlICdsZWZ0JzpcbiAgICAgIHJldHVybiAnbGVmdCc7XG4gICAgY2FzZSAncmlnaHQnOlxuICAgICAgcmV0dXJuICdyaWdodCc7XG4gICAgLyogaXN0YW5idWwgaWdub3JlIG5leHQgKi9cbiAgICBkZWZhdWx0OlxuICAgICAgdGhyb3cgYFNreUFmZml4SG9yaXpvbnRhbEFsaWdubWVudCBkb2VzIG5vdCBoYXZlIGEgbWF0Y2hpbmcgdmFsdWUgZm9yICcke2FsaWdubWVudH0nIWA7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,66 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Input, Renderer2, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class SkyDropdownItemComponent {
+    constructor(elementRef, changeDetector, renderer) {
+        this.elementRef = elementRef;
+        this.changeDetector = changeDetector;
+        this.renderer = renderer;
+        this.isActive = false;
+        this.isDisabled = false;
+    }
+    /**
+     * Specifies an 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;
+    }
+    get ariaRole() {
+        return this._ariaRole || 'menuitem';
+    }
+    get buttonElement() {
+        return this.elementRef.nativeElement.querySelector('button,a');
+    }
+    ngAfterViewInit() {
+        this.isDisabled = !this.isFocusable();
+        // Make sure anchor elements are tab-able.
+        const buttonElement = this.buttonElement;
+        /* istanbul ignore else */
+        if (buttonElement) {
+            this.renderer.setAttribute(buttonElement, 'tabIndex', '0');
+        }
+        this.changeDetector.detectChanges();
+    }
+    focusElement(enableNativeFocus) {
+        this.isActive = true;
+        if (enableNativeFocus) {
+            this.buttonElement.focus();
+        }
+        this.changeDetector.detectChanges();
+    }
+    isFocusable() {
+        /*tslint:disable no-null-keyword */
+        const isFocusable = this.buttonElement &&
+            this.buttonElement.getAttribute('disabled') === null;
+        /*tslint:enable */
+        return isFocusable;
+    }
+    resetState() {
+        this.isActive = false;
+        this.changeDetector.markForCheck();
+    }
+}
+SkyDropdownItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDropdownItemComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+SkyDropdownItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.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    'sky-dropdown-item-disabled': isDisabled\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,.sky-dropdown-item:hover{background-color:#eeeeef}.sky-dropdown-item.sky-dropdown-item-disabled{cursor:default}.sky-dropdown-item.sky-dropdown-item-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:8px 20px;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,.sky-theme-modern .sky-dropdown-item>a:active,.sky-theme-modern .sky-dropdown-item>button:focus,.sky-theme-modern .sky-dropdown-item>button:active{outline:solid 2px #1870B8;outline-offset:-2px}.sky-theme-modern .sky-dropdown-item>a:focus:not(:active),.sky-theme-modern .sky-dropdown-item>button:focus: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"], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.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    'sky-dropdown-item-disabled': isDisabled\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,.sky-dropdown-item:hover{background-color:#eeeeef}.sky-dropdown-item.sky-dropdown-item-disabled{cursor:default}.sky-dropdown-item.sky-dropdown-item-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:8px 20px;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,.sky-theme-modern .sky-dropdown-item>a:active,.sky-theme-modern .sky-dropdown-item>button:focus,.sky-theme-modern .sky-dropdown-item>button:active{outline:solid 2px #1870B8;outline-offset:-2px}.sky-theme-modern .sky-dropdown-item>a:focus:not(:active),.sky-theme-modern .sky-dropdown-item>button:focus: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/esm2020/lib/modules/dropdown/dropdown-menu.component.mjs

@@ -0,0 +1,301 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, ElementRef, EventEmitter, Input, Optional, Output, QueryList, ViewEncapsulation, } from '@angular/core';
+import { Subject, fromEvent as observableFromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyDropdownItemComponent } from './dropdown-item.component';
+import { SkyDropdownComponent } from './dropdown.component';
+import { SkyDropdownMessageType } from './types/dropdown-message-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./dropdown.component";
+let nextId = 0;
+export class SkyDropdownMenuComponent {
+    constructor(changeDetector, elementRef, dropdownComponent) {
+        this.changeDetector = changeDetector;
+        this.elementRef = elementRef;
+        this.dropdownComponent = 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.
+         */
+        this.menuChanges = new EventEmitter();
+        this.dropdownMenuId = `sky-dropdown-menu-${++nextId}`;
+        this.ngUnsubscribe = new Subject();
+        this._menuIndex = 0;
+    }
+    /**
+     * Specifies an 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;
+    }
+    get ariaRole() {
+        return this._ariaRole || 'menu';
+    }
+    /**
+     * Indicates 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
+     */
+    set useNativeFocus(value) {
+        this._useNativeFocus = value;
+    }
+    get useNativeFocus() {
+        if (this._useNativeFocus === undefined) {
+            return true;
+        }
+        return this._useNativeFocus;
+    }
+    get hasFocusableItems() {
+        const found = this.menuItems.find((item) => item.isFocusable());
+        return found !== undefined;
+    }
+    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;
+    }
+    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) => {
+                /* tslint:disable-next-line:switch-default */
+                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();
+        this.ngUnsubscribe = undefined;
+    }
+    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((item, i) => {
+            return 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();
+            /*tslint:disable-next-line:switch-default*/
+            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(() => {
+            this.dropdownComponent.isMouseEnter = true;
+        });
+        observableFromEvent(dropdownMenuElement, 'mouseleave')
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(() => {
+            this.dropdownComponent.isMouseEnter = false;
+            // Allow the dropdown component to set isMouseEnter before checking if the close action
+            // should be taken.
+            setTimeout(() => {
+                if (this.dropdownComponent.trigger === 'hover' &&
+                    this.dropdownComponent.isMouseEnter === false) {
+                    this.sendMessage(SkyDropdownMessageType.Close);
+                }
+            });
+        });
+    }
+}
+SkyDropdownMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyDropdownMenuComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.SkyDropdownComponent, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+SkyDropdownMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.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-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: "13.2.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-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@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   * Specifies the HTML element ID (without the leading `#`) of the element that labels\n   * the dropdown menu. This sets the dropdown menu's `aria-labelledby` attribute\n   * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).\n   */\n  @Input()\n  public ariaLabelledBy: string;\n\n  /**\n   * Specifies an 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) {\n    this._ariaRole = value;\n  }\n\n  public get ariaRole(): string {\n    return this._ariaRole || 'menu';\n  }\n\n  /**\n   * Indicates 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   */\n  @Input()\n  public set useNativeFocus(value: boolean) {\n    this._useNativeFocus = value;\n  }\n\n  public get useNativeFocus(): boolean {\n    if (this._useNativeFocus === undefined) {\n      return true;\n    }\n\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   */\n  @Output()\n  public menuChanges = new EventEmitter<SkyDropdownMenuChange>();\n\n  public dropdownMenuId = `sky-dropdown-menu-${++nextId}`;\n\n  private get hasFocusableItems(): boolean {\n    const found = this.menuItems.find((item) => item.isFocusable());\n    return found !== undefined;\n  }\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  private ngUnsubscribe = new Subject();\n\n  private _ariaRole: string;\n\n  private _menuIndex = 0;\n\n  private _useNativeFocus: boolean;\n\n  constructor(\n    private changeDetector: ChangeDetectorRef,\n    private elementRef: ElementRef,\n    @Optional() private dropdownComponent: SkyDropdownComponent\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          /* tslint:disable-next-line:switch-default */\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    this.ngUnsubscribe = undefined;\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  private resetItemsActiveState() {\n    this.menuItems.forEach((item: SkyDropdownItemComponent) => {\n      item.resetState();\n    });\n  }\n\n  private focusItem(item: SkyDropdownItemComponent): void {\n    this.resetItemsActiveState();\n    item.focusElement(this.useNativeFocus);\n    this.menuChanges.emit({\n      activeIndex: this.menuIndex,\n    });\n  }\n\n  private getItemByIndex(index: number): SkyDropdownItemComponent {\n    return this.menuItems.find((item: any, i: number) => {\n      return i === index;\n    });\n  }\n\n  private 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  private sendMessage(type: SkyDropdownMessageType): void {\n    this.dropdownComponent.messageStream.next({ type });\n  }\n\n  private addEventListeners(): void {\n    const dropdownMenuElement = this.elementRef.nativeElement;\n\n    observableFromEvent(dropdownMenuElement, 'click')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((event: MouseEvent) => {\n        this.selectItemByEventTarget(event.target);\n      });\n\n    observableFromEvent(dropdownMenuElement, 'keydown')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((event: KeyboardEvent) => {\n        const key = event.key.toLowerCase();\n\n        /*tslint:disable-next-line:switch-default*/\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        this.dropdownComponent.isMouseEnter = true;\n      });\n\n    observableFromEvent(dropdownMenuElement, 'mouseleave')\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(() => {\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.trigger === 'hover' &&\n            this.dropdownComponent.isMouseEnter === false\n          ) {\n            this.sendMessage(SkyDropdownMessageType.Close);\n          }\n        });\n      });\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"]}