@angular/cdk-experimental 13.0.0-next.7 → 13.0.0-rc.2

package/esm2020/menu/menu.mjs

@@ -0,0 +1,316 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directive, Input, Output, EventEmitter, QueryList, ContentChildren, Optional, NgZone, HostListener, ElementRef, Inject, Self, } from '@angular/core';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, ESCAPE, TAB, hasModifierKey, } from '@angular/cdk/keycodes';
+import { Directionality } from '@angular/cdk/bidi';
+import { merge } from 'rxjs';
+import { take, takeUntil, startWith, mergeMap, mapTo, mergeAll, switchMap } from 'rxjs/operators';
+import { CdkMenuGroup } from './menu-group';
+import { CdkMenuPanel } from './menu-panel';
+import { CDK_MENU } from './menu-interface';
+import { CdkMenuItem } from './menu-item';
+import { NoopMenuStack } from './menu-stack';
+import { PointerFocusTracker } from './pointer-focus-tracker';
+import { MENU_AIM } from './menu-aim';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "./menu-panel";
+/**
+ * Directive which configures the element as a Menu which should contain child elements marked as
+ * CdkMenuItem or CdkMenuGroup. Sets the appropriate role and aria-attributes for a menu and
+ * contains accessible keyboard and mouse handling logic.
+ *
+ * It also acts as a RadioGroup for elements marked with role `menuitemradio`.
+ */
+export class CdkMenu extends CdkMenuGroup {
+    constructor(_ngZone, _elementRef, _menuAim, _dir, 
+    // `CdkMenuPanel` is always used in combination with a `CdkMenu`.
+    // tslint:disable-next-line: lightweight-tokens
+    _menuPanel) {
+        super();
+        this._ngZone = _ngZone;
+        this._elementRef = _elementRef;
+        this._menuAim = _menuAim;
+        this._dir = _dir;
+        this._menuPanel = _menuPanel;
+        /**
+         * Sets the aria-orientation attribute and determines where menus will be opened.
+         * Does not affect styling/layout.
+         */
+        this.orientation = 'vertical';
+        /** Event emitted when the menu is closed. */
+        this.closed = new EventEmitter();
+        // We provide a default MenuStack implementation in case the menu is an inline menu.
+        // For Menus part of a MenuBar nested within a MenuPanel this will be overwritten
+        // to the correct parent MenuStack.
+        /** Track the Menus making up the open menu stack. */
+        this._menuStack = new NoopMenuStack();
+    }
+    ngOnInit() {
+        this._registerWithParentPanel();
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+        this._completeChangeEmitter();
+        this._setKeyManager();
+        this._subscribeToMenuOpen();
+        this._subscribeToMenuStack();
+        this._subscribeToMouseManager();
+        this._menuAim?.initialize(this, this._pointerTracker);
+    }
+    // In Ivy the `host` metadata will be merged, whereas in ViewEngine it is overridden. In order
+    // to avoid double event listeners, we need to use `HostListener`. Once Ivy is the default, we
+    // can move this back into `host`.
+    // tslint:disable:no-host-decorator-in-concrete
+    /** Place focus on the first MenuItem in the menu and set the focus origin. */
+    focusFirstItem(focusOrigin = 'program') {
+        this._keyManager.setFocusOrigin(focusOrigin);
+        this._keyManager.setFirstItemActive();
+    }
+    /** Place focus on the last MenuItem in the menu and set the focus origin. */
+    focusLastItem(focusOrigin = 'program') {
+        this._keyManager.setFocusOrigin(focusOrigin);
+        this._keyManager.setLastItemActive();
+    }
+    // In Ivy the `host` metadata will be merged, whereas in ViewEngine it is overridden. In order
+    // to avoid double event listeners, we need to use `HostListener`. Once Ivy is the default, we
+    // can move this back into `host`.
+    // tslint:disable:no-host-decorator-in-concrete
+    /** Handle keyboard events for the Menu. */
+    _handleKeyEvent(event) {
+        const keyManager = this._keyManager;
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+            case RIGHT_ARROW:
+                if (this._isHorizontal()) {
+                    event.preventDefault();
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.onKeydown(event);
+                }
+                break;
+            case UP_ARROW:
+            case DOWN_ARROW:
+                if (!this._isHorizontal()) {
+                    event.preventDefault();
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.onKeydown(event);
+                }
+                break;
+            case ESCAPE:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this._menuStack.close(this, 2 /* currentItem */);
+                }
+                break;
+            case TAB:
+                this._menuStack.closeAll();
+                break;
+            default:
+                keyManager.onKeydown(event);
+        }
+    }
+    /** Register this menu with its enclosing parent menu panel */
+    _registerWithParentPanel() {
+        this._getMenuPanel()?._registerMenu(this);
+    }
+    /**
+     * Get the enclosing CdkMenuPanel defaulting to the injected reference over the developer
+     * provided reference.
+     */
+    _getMenuPanel() {
+        return this._menuPanel || this._explicitPanel;
+    }
+    /**
+     * Complete the change emitter if there are any nested MenuGroups or register to complete the
+     * change emitter if a MenuGroup is rendered at some point
+     */
+    _completeChangeEmitter() {
+        if (this._hasNestedGroups()) {
+            this.change.complete();
+        }
+        else {
+            this._nestedGroups.changes.pipe(take(1)).subscribe(() => this.change.complete());
+        }
+    }
+    /** Return true if there are nested CdkMenuGroup elements within the Menu */
+    _hasNestedGroups() {
+        // view engine has a bug where @ContentChildren will return the current element
+        // along with children if the selectors match - not just the children.
+        // Here, if there is at least one element, we check to see if the first element is a CdkMenu in
+        // order to ensure that we return true iff there are child CdkMenuGroup elements.
+        return this._nestedGroups.length > 0 && !(this._nestedGroups.first instanceof CdkMenu);
+    }
+    /** Setup the FocusKeyManager with the correct orientation for the menu. */
+    _setKeyManager() {
+        this._keyManager = new FocusKeyManager(this._allItems)
+            .withWrap()
+            .withTypeAhead()
+            .withHomeAndEnd();
+        if (this._isHorizontal()) {
+            this._keyManager.withHorizontalOrientation(this._dir?.value || 'ltr');
+        }
+        else {
+            this._keyManager.withVerticalOrientation();
+        }
+    }
+    /**
+     * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
+     * with the latest menu item under mouse focus.
+     */
+    _subscribeToMouseManager() {
+        this._ngZone.runOutsideAngular(() => {
+            this._pointerTracker = new PointerFocusTracker(this._allItems);
+            this._pointerTracker.entered
+                .pipe(takeUntil(this.closed))
+                .subscribe(item => this._keyManager.setActiveItem(item));
+        });
+    }
+    /** Subscribe to the MenuStack close and empty observables. */
+    _subscribeToMenuStack() {
+        this._menuStack.closed
+            .pipe(takeUntil(this.closed))
+            .subscribe(item => this._closeOpenMenu(item));
+        this._menuStack.emptied
+            .pipe(takeUntil(this.closed))
+            .subscribe(event => this._toggleMenuFocus(event));
+    }
+    /**
+     * Close the open menu if the current active item opened the requested MenuStackItem.
+     * @param item the MenuStackItem requested to be closed.
+     */
+    _closeOpenMenu(menu) {
+        const keyManager = this._keyManager;
+        const trigger = this._openItem;
+        if (menu === trigger?.getMenuTrigger()?.getMenu()) {
+            trigger?.getMenuTrigger()?.closeMenu();
+            // If the user has moused over a sibling item we want to focus the element under mouse focus
+            // not the trigger which previously opened the now closed menu.
+            if (trigger) {
+                keyManager.setActiveItem(this._pointerTracker?.activeElement || trigger);
+            }
+        }
+    }
+    /** Set focus the either the current, previous or next item based on the FocusNext event. */
+    _toggleMenuFocus(event) {
+        const keyManager = this._keyManager;
+        switch (event) {
+            case 0 /* nextItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setNextItemActive();
+                break;
+            case 1 /* previousItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setPreviousItemActive();
+                break;
+            case 2 /* currentItem */:
+                if (keyManager.activeItem) {
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.setActiveItem(keyManager.activeItem);
+                }
+                break;
+        }
+    }
+    // TODO(andy9775): remove duplicate logic between menu an menu bar
+    /**
+     * Subscribe to the menu trigger's open events in order to track the trigger which opened the menu
+     * and stop tracking it when the menu is closed.
+     */
+    _subscribeToMenuOpen() {
+        const exitCondition = merge(this._allItems.changes, this.closed);
+        this._allItems.changes
+            .pipe(startWith(this._allItems), mergeMap((list) => list
+            .filter(item => item.hasMenu())
+            .map(item => item.getMenuTrigger().opened.pipe(mapTo(item), takeUntil(exitCondition)))), mergeAll(), switchMap((item) => {
+            this._openItem = item;
+            return item.getMenuTrigger().closed;
+        }), takeUntil(this.closed))
+            .subscribe(() => (this._openItem = undefined));
+    }
+    /** Return true if this menu has been configured in a horizontal orientation. */
+    _isHorizontal() {
+        return this.orientation === 'horizontal';
+    }
+    /**
+     * Return true if this menu is an inline menu. That is, it does not exist in a pop-up and is
+     * always visible in the dom.
+     */
+    _isInline() {
+        // NoopMenuStack is the default. If this menu is not inline than the NoopMenuStack is replaced
+        // automatically.
+        return this._menuStack instanceof NoopMenuStack;
+    }
+    ngOnDestroy() {
+        this._emitClosedEvent();
+        this._pointerTracker?.destroy();
+    }
+    /** Emit and complete the closed event emitter */
+    _emitClosedEvent() {
+        this.closed.next();
+        this.closed.complete();
+    }
+}
+CdkMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenu, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: MENU_AIM, optional: true, self: true }, { token: i1.Directionality, optional: true }, { token: i2.CdkMenuPanel, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenu.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: CdkMenu, selector: "[cdkMenu]", inputs: { orientation: ["cdkMenuOrientation", "orientation"], _explicitPanel: ["cdkMenuPanel", "_explicitPanel"] }, outputs: { closed: "closed" }, host: { attributes: { "role": "menu" }, listeners: { "focus": "focusFirstItem()", "keydown": "_handleKeyEvent($event)" }, properties: { "tabindex": "_isInline() ? 0 : null", "class.cdk-menu-inline": "_isInline()", "attr.aria-orientation": "orientation" }, classAttribute: "cdk-menu" }, providers: [
+        { provide: CdkMenuGroup, useExisting: CdkMenu },
+        { provide: CDK_MENU, useExisting: CdkMenu },
+    ], queries: [{ propertyName: "_nestedGroups", predicate: CdkMenuGroup, descendants: true }, { propertyName: "_allItems", predicate: CdkMenuItem, descendants: true }], exportAs: ["cdkMenu"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkMenu, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenu]',
+                    exportAs: 'cdkMenu',
+                    host: {
+                        '[tabindex]': '_isInline() ? 0 : null',
+                        'role': 'menu',
+                        'class': 'cdk-menu',
+                        '[class.cdk-menu-inline]': '_isInline()',
+                        '[attr.aria-orientation]': 'orientation',
+                    },
+                    providers: [
+                        { provide: CdkMenuGroup, useExisting: CdkMenu },
+                        { provide: CDK_MENU, useExisting: CdkMenu },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MENU_AIM]
+                }] }, { type: i1.Directionality, decorators: [{
+                    type: Optional
+                }] }, { type: i2.CdkMenuPanel, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { orientation: [{
+                type: Input,
+                args: ['cdkMenuOrientation']
+            }], closed: [{
+                type: Output
+            }], _nestedGroups: [{
+                type: ContentChildren,
+                args: [CdkMenuGroup, { descendants: true }]
+            }], _allItems: [{
+                type: ContentChildren,
+                args: [CdkMenuItem, { descendants: true }]
+            }], _explicitPanel: [{
+                type: Input,
+                args: ['cdkMenuPanel']
+            }], 
+        /** Place focus on the first MenuItem in the menu and set the focus origin. */
+        focusFirstItem: [{
+                type: HostListener,
+                args: ['focus']
+            }], 
+        /** Handle keyboard events for the Menu. */
+        _handleKeyEvent: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/menu/menu.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,SAAS,EACT,KAAK,EACL,MAAM,EACN,YAAY,EACZ,SAAS,EACT,eAAe,EAGf,QAAQ,EAER,MAAM,EACN,YAAY,EACZ,UAAU,EACV,MAAM,EACN,IAAI,GACL,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,eAAe,EAAc,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EACL,UAAU,EACV,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,GAAG,EACH,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAC,KAAK,EAAC,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAO,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,EAAsC,aAAa,EAAC,MAAM,cAAc,CAAC;AAChF,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAC,QAAQ,EAAU,MAAM,YAAY,CAAC;;;;AAE7C;;;;;;GAMG;AAgBH,MAAM,OAAO,OAAQ,SAAQ,YAAY;IA0CvC,YACmB,OAAe,EACvB,WAAoC,EACU,QAAkB,EAC5C,IAAqB;IAClD,iEAAiE;IACjE,+CAA+C;IAClB,UAAyB;QAEtD,KAAK,EAAE,CAAC;QARS,YAAO,GAAP,OAAO,CAAQ;QACvB,gBAAW,GAAX,WAAW,CAAyB;QACU,aAAQ,GAAR,QAAQ,CAAU;QAC5C,SAAI,GAAJ,IAAI,CAAiB;QAGrB,eAAU,GAAV,UAAU,CAAe;QAhDxD;;;WAGG;QAC0B,gBAAW,GAA8B,UAAU,CAAC;QAEjF,6CAA6C;QAC1B,WAAM,GAAoD,IAAI,YAAY,EAAE,CAAC;QAEhG,oFAAoF;QACpF,iFAAiF;QACjF,mCAAmC;QACnC,qDAAqD;QACrD,eAAU,GAAc,IAAI,aAAa,EAAE,CAAC;IAsC5C,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAClC,CAAC;IAEQ,kBAAkB;QACzB,KAAK,CAAC,kBAAkB,EAAE,CAAC;QAE3B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEhC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,eAAgB,CAAC,CAAC;IACzD,CAAC;IAED,8FAA8F;IAC9F,8FAA8F;IAC9F,kCAAkC;IAClC,+CAA+C;IAE/C,8EAA8E;IAC9E,cAAc,CAAC,cAA2B,SAAS;QACjD,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAC7C,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;IACxC,CAAC;IAED,6EAA6E;IAC7E,aAAa,CAAC,cAA2B,SAAS;QAChD,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAC7C,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;IACvC,CAAC;IAED,8FAA8F;IAC9F,8FAA8F;IAC9F,kCAAkC;IAClC,+CAA+C;IAE/C,2CAA2C;IAC3C,eAAe,CAAC,KAAoB;QAClC,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,QAAQ,KAAK,CAAC,OAAO,EAAE;YACrB,KAAK,UAAU,CAAC;YAChB,KAAK,WAAW;gBACd,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;oBACxB,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;oBACtC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;iBAC7B;gBACD,MAAM;YAER,KAAK,QAAQ,CAAC;YACd,KAAK,UAAU;gBACb,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE;oBACzB,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;oBACtC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;iBAC7B;gBACD,MAAM;YAER,KAAK,MAAM;gBACT,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE;oBAC1B,KAAK,CAAC,cAAc,EAAE,CAAC;oBACvB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,sBAAwB,CAAC;iBACpD;gBACD,MAAM;YAER,KAAK,GAAG;gBACN,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;gBAC3B,MAAM;YAER;gBACE,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SAC/B;IACH,CAAC;IAED,8DAA8D;IACtD,wBAAwB;QAC9B,IAAI,CAAC,aAAa,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACK,aAAa;QACnB,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,cAAc,CAAC;IAChD,CAAC;IAED;;;OAGG;IACK,sBAAsB;QAC5B,IAAI,IAAI,CAAC,gBAAgB,EAAE,EAAE;YAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;SACxB;aAAM;YACL,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;SAClF;IACH,CAAC;IAED,4EAA4E;IACpE,gBAAgB;QACtB,+EAA+E;QAC/E,sEAAsE;QACtE,+FAA+F;QAC/F,iFAAiF;QACjF,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,YAAY,OAAO,CAAC,CAAC;IACzF,CAAC;IAED,2EAA2E;IACnE,cAAc;QACpB,IAAI,CAAC,WAAW,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC;aACnD,QAAQ,EAAE;aACV,aAAa,EAAE;aACf,cAAc,EAAE,CAAC;QAEpB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE;YACxB,IAAI,CAAC,WAAW,CAAC,yBAAyB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,IAAI,KAAK,CAAC,CAAC;SACvE;aAAM;YACL,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,CAAC;SAC5C;IACH,CAAC;IAED;;;OAGG;IACK,wBAAwB;QAC9B,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAClC,IAAI,CAAC,eAAe,GAAG,IAAI,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC/D,IAAI,CAAC,eAAe,CAAC,OAAO;iBACzB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;iBAC5B,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,8DAA8D;IACtD,qBAAqB;QAC3B,IAAI,CAAC,UAAU,CAAC,MAAM;aACnB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAC5B,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;QAEhD,IAAI,CAAC,UAAU,CAAC,OAAO;aACpB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAC5B,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACK,cAAc,CAAC,IAA+B;QACpD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;QAC/B,IAAI,IAAI,KAAK,OAAO,EAAE,cAAc,EAAE,EAAE,OAAO,EAAE,EAAE;YACjD,OAAO,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,CAAC;YACvC,4FAA4F;YAC5F,+DAA+D;YAC/D,IAAI,OAAO,EAAE;gBACX,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,eAAe,EAAE,aAAa,IAAI,OAAO,CAAC,CAAC;aAC1E;SACF;IACH,CAAC;IAED,4FAA4F;IACpF,gBAAgB,CAAC,KAA4B;QACnD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,QAAQ,KAAK,EAAE;YACb;gBACE,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;gBACtC,UAAU,CAAC,iBAAiB,EAAE,CAAC;gBAC/B,MAAM;YAER;gBACE,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;gBACtC,UAAU,CAAC,qBAAqB,EAAE,CAAC;gBACnC,MAAM;YAER;gBACE,IAAI,UAAU,CAAC,UAAU,EAAE;oBACzB,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;oBACtC,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;iBACjD;gBACD,MAAM;SACT;IACH,CAAC;IAED,kEAAkE;IAClE;;;OAGG;IACK,oBAAoB;QAC1B,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACjE,IAAI,CAAC,SAAS,CAAC,OAAO;aACnB,IAAI,CACH,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EACzB,QAAQ,CAAC,CAAC,IAA4B,EAAE,EAAE,CACxC,IAAI;aACD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;aAC9B,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,EAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAC1F,EACD,QAAQ,EAAE,EACV,SAAS,CAAC,CAAC,IAAiB,EAAE,EAAE;YAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,OAAO,IAAI,CAAC,cAAc,EAAG,CAAC,MAAM,CAAC;QACvC,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CACvB;aACA,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,gFAAgF;IACxE,aAAa;QACnB,OAAO,IAAI,CAAC,WAAW,KAAK,YAAY,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,SAAS;QACP,8FAA8F;QAC9F,iBAAiB;QACjB,OAAO,IAAI,CAAC,UAAU,YAAY,aAAa,CAAC;IAClD,CAAC;IAEQ,WAAW;QAClB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,eAAe,EAAE,OAAO,EAAE,CAAC;IAClC,CAAC;IAED,iDAAiD;IACzC,gBAAgB;QACtB,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;;4GAnSU,OAAO,kEA6CY,QAAQ;gGA7C3B,OAAO,qdALP;QACT,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAC;QAC7C,EAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAC;KAC1C,wDAyBgB,YAAY,+DAIZ,WAAW;mGA3BjB,OAAO;kBAfnB,SAAS;mBAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,SAAS;oBACnB,IAAI,EAAE;wBACJ,YAAY,EAAE,wBAAwB;wBACtC,MAAM,EAAE,MAAM;wBACd,OAAO,EAAE,UAAU;wBACnB,yBAAyB,EAAE,aAAa;wBACxC,yBAAyB,EAAE,aAAa;qBACzC;oBACD,SAAS,EAAE;wBACT,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,SAAS,EAAC;wBAC7C,EAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,SAAS,EAAC;qBAC1C;iBACF;;0BA8CI,IAAI;;0BAAI,QAAQ;;0BAAI,MAAM;2BAAC,QAAQ;;0BACnC,QAAQ;;0BAGR,QAAQ;4CA5CkB,WAAW;sBAAvC,KAAK;uBAAC,oBAAoB;gBAGR,MAAM;sBAAxB,MAAM;gBAgBU,aAAa;sBAD7B,eAAe;uBAAC,YAAY,EAAE,EAAC,WAAW,EAAE,IAAI,EAAC;gBAKjC,SAAS;sBADzB,eAAe;uBAAC,WAAW,EAAE,EAAC,WAAW,EAAE,IAAI,EAAC;gBAaT,cAAc;sBAArD,KAAK;uBAAC,cAAc;;QAmCrB,8EAA8E;QAC9E,cAAc;sBAFb,YAAY;uBAAC,OAAO;;QAkBrB,2CAA2C;QAC3C,eAAe;sBAFd,YAAY;uBAAC,SAAS,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Directive,\n  Input,\n  Output,\n  EventEmitter,\n  QueryList,\n  ContentChildren,\n  AfterContentInit,\n  OnDestroy,\n  Optional,\n  OnInit,\n  NgZone,\n  HostListener,\n  ElementRef,\n  Inject,\n  Self,\n} from '@angular/core';\nimport {FocusKeyManager, FocusOrigin} from '@angular/cdk/a11y';\nimport {\n  LEFT_ARROW,\n  RIGHT_ARROW,\n  UP_ARROW,\n  DOWN_ARROW,\n  ESCAPE,\n  TAB,\n  hasModifierKey,\n} from '@angular/cdk/keycodes';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {merge} from 'rxjs';\nimport {take, takeUntil, startWith, mergeMap, mapTo, mergeAll, switchMap} from 'rxjs/operators';\nimport {CdkMenuGroup} from './menu-group';\nimport {CdkMenuPanel} from './menu-panel';\nimport {Menu, CDK_MENU} from './menu-interface';\nimport {CdkMenuItem} from './menu-item';\nimport {MenuStack, MenuStackItem, FocusNext, NoopMenuStack} from './menu-stack';\nimport {PointerFocusTracker} from './pointer-focus-tracker';\nimport {MENU_AIM, MenuAim} from './menu-aim';\n\n/**\n * Directive which configures the element as a Menu which should contain child elements marked as\n * CdkMenuItem or CdkMenuGroup. Sets the appropriate role and aria-attributes for a menu and\n * contains accessible keyboard and mouse handling logic.\n *\n * It also acts as a RadioGroup for elements marked with role `menuitemradio`.\n */\n@Directive({\n  selector: '[cdkMenu]',\n  exportAs: 'cdkMenu',\n  host: {\n    '[tabindex]': '_isInline() ? 0 : null',\n    'role': 'menu',\n    'class': 'cdk-menu',\n    '[class.cdk-menu-inline]': '_isInline()',\n    '[attr.aria-orientation]': 'orientation',\n  },\n  providers: [\n    {provide: CdkMenuGroup, useExisting: CdkMenu},\n    {provide: CDK_MENU, useExisting: CdkMenu},\n  ],\n})\nexport class CdkMenu extends CdkMenuGroup implements Menu, AfterContentInit, OnInit, OnDestroy {\n  /**\n   * Sets the aria-orientation attribute and determines where menus will be opened.\n   * Does not affect styling/layout.\n   */\n  @Input('cdkMenuOrientation') orientation: 'horizontal' | 'vertical' = 'vertical';\n\n  /** Event emitted when the menu is closed. */\n  @Output() readonly closed: EventEmitter<void | 'click' | 'tab' | 'escape'> = new EventEmitter();\n\n  // We provide a default MenuStack implementation in case the menu is an inline menu.\n  // For Menus part of a MenuBar nested within a MenuPanel this will be overwritten\n  // to the correct parent MenuStack.\n  /** Track the Menus making up the open menu stack. */\n  _menuStack: MenuStack = new NoopMenuStack();\n\n  /** Handles keyboard events for the menu. */\n  private _keyManager: FocusKeyManager<CdkMenuItem>;\n\n  /** Manages items under mouse focus. */\n  private _pointerTracker?: PointerFocusTracker<CdkMenuItem>;\n\n  /** List of nested CdkMenuGroup elements */\n  @ContentChildren(CdkMenuGroup, {descendants: true})\n  private readonly _nestedGroups: QueryList<CdkMenuGroup>;\n\n  /** All child MenuItem elements nested in this Menu. */\n  @ContentChildren(CdkMenuItem, {descendants: true})\n  private readonly _allItems: QueryList<CdkMenuItem>;\n\n  /** The Menu Item which triggered the open submenu. */\n  private _openItem?: CdkMenuItem;\n\n  /**\n   * A reference to the enclosing parent menu panel.\n   *\n   * Required to be set when using ViewEngine since ViewEngine does support injecting a reference to\n   * the parent directive if the parent directive is placed on an `ng-template`. If using Ivy, the\n   * injected value will be used over this one.\n   */\n  @Input('cdkMenuPanel') private readonly _explicitPanel?: CdkMenuPanel;\n\n  constructor(\n    private readonly _ngZone: NgZone,\n    readonly _elementRef: ElementRef<HTMLElement>,\n    @Self() @Optional() @Inject(MENU_AIM) private readonly _menuAim?: MenuAim,\n    @Optional() private readonly _dir?: Directionality,\n    // `CdkMenuPanel` is always used in combination with a `CdkMenu`.\n    // tslint:disable-next-line: lightweight-tokens\n    @Optional() private readonly _menuPanel?: CdkMenuPanel,\n  ) {\n    super();\n  }\n\n  ngOnInit() {\n    this._registerWithParentPanel();\n  }\n\n  override ngAfterContentInit() {\n    super.ngAfterContentInit();\n\n    this._completeChangeEmitter();\n    this._setKeyManager();\n    this._subscribeToMenuOpen();\n    this._subscribeToMenuStack();\n    this._subscribeToMouseManager();\n\n    this._menuAim?.initialize(this, this._pointerTracker!);\n  }\n\n  // In Ivy the `host` metadata will be merged, whereas in ViewEngine it is overridden. In order\n  // to avoid double event listeners, we need to use `HostListener`. Once Ivy is the default, we\n  // can move this back into `host`.\n  // tslint:disable:no-host-decorator-in-concrete\n  @HostListener('focus')\n  /** Place focus on the first MenuItem in the menu and set the focus origin. */\n  focusFirstItem(focusOrigin: FocusOrigin = 'program') {\n    this._keyManager.setFocusOrigin(focusOrigin);\n    this._keyManager.setFirstItemActive();\n  }\n\n  /** Place focus on the last MenuItem in the menu and set the focus origin. */\n  focusLastItem(focusOrigin: FocusOrigin = 'program') {\n    this._keyManager.setFocusOrigin(focusOrigin);\n    this._keyManager.setLastItemActive();\n  }\n\n  // In Ivy the `host` metadata will be merged, whereas in ViewEngine it is overridden. In order\n  // to avoid double event listeners, we need to use `HostListener`. Once Ivy is the default, we\n  // can move this back into `host`.\n  // tslint:disable:no-host-decorator-in-concrete\n  @HostListener('keydown', ['$event'])\n  /** Handle keyboard events for the Menu. */\n  _handleKeyEvent(event: KeyboardEvent) {\n    const keyManager = this._keyManager;\n    switch (event.keyCode) {\n      case LEFT_ARROW:\n      case RIGHT_ARROW:\n        if (this._isHorizontal()) {\n          event.preventDefault();\n          keyManager.setFocusOrigin('keyboard');\n          keyManager.onKeydown(event);\n        }\n        break;\n\n      case UP_ARROW:\n      case DOWN_ARROW:\n        if (!this._isHorizontal()) {\n          event.preventDefault();\n          keyManager.setFocusOrigin('keyboard');\n          keyManager.onKeydown(event);\n        }\n        break;\n\n      case ESCAPE:\n        if (!hasModifierKey(event)) {\n          event.preventDefault();\n          this._menuStack.close(this, FocusNext.currentItem);\n        }\n        break;\n\n      case TAB:\n        this._menuStack.closeAll();\n        break;\n\n      default:\n        keyManager.onKeydown(event);\n    }\n  }\n\n  /** Register this menu with its enclosing parent menu panel */\n  private _registerWithParentPanel() {\n    this._getMenuPanel()?._registerMenu(this);\n  }\n\n  /**\n   * Get the enclosing CdkMenuPanel defaulting to the injected reference over the developer\n   * provided reference.\n   */\n  private _getMenuPanel() {\n    return this._menuPanel || this._explicitPanel;\n  }\n\n  /**\n   * Complete the change emitter if there are any nested MenuGroups or register to complete the\n   * change emitter if a MenuGroup is rendered at some point\n   */\n  private _completeChangeEmitter() {\n    if (this._hasNestedGroups()) {\n      this.change.complete();\n    } else {\n      this._nestedGroups.changes.pipe(take(1)).subscribe(() => this.change.complete());\n    }\n  }\n\n  /** Return true if there are nested CdkMenuGroup elements within the Menu */\n  private _hasNestedGroups() {\n    // view engine has a bug where @ContentChildren will return the current element\n    // along with children if the selectors match - not just the children.\n    // Here, if there is at least one element, we check to see if the first element is a CdkMenu in\n    // order to ensure that we return true iff there are child CdkMenuGroup elements.\n    return this._nestedGroups.length > 0 && !(this._nestedGroups.first instanceof CdkMenu);\n  }\n\n  /** Setup the FocusKeyManager with the correct orientation for the menu. */\n  private _setKeyManager() {\n    this._keyManager = new FocusKeyManager(this._allItems)\n      .withWrap()\n      .withTypeAhead()\n      .withHomeAndEnd();\n\n    if (this._isHorizontal()) {\n      this._keyManager.withHorizontalOrientation(this._dir?.value || 'ltr');\n    } else {\n      this._keyManager.withVerticalOrientation();\n    }\n  }\n\n  /**\n   * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated\n   * with the latest menu item under mouse focus.\n   */\n  private _subscribeToMouseManager() {\n    this._ngZone.runOutsideAngular(() => {\n      this._pointerTracker = new PointerFocusTracker(this._allItems);\n      this._pointerTracker.entered\n        .pipe(takeUntil(this.closed))\n        .subscribe(item => this._keyManager.setActiveItem(item));\n    });\n  }\n\n  /** Subscribe to the MenuStack close and empty observables. */\n  private _subscribeToMenuStack() {\n    this._menuStack.closed\n      .pipe(takeUntil(this.closed))\n      .subscribe(item => this._closeOpenMenu(item));\n\n    this._menuStack.emptied\n      .pipe(takeUntil(this.closed))\n      .subscribe(event => this._toggleMenuFocus(event));\n  }\n\n  /**\n   * Close the open menu if the current active item opened the requested MenuStackItem.\n   * @param item the MenuStackItem requested to be closed.\n   */\n  private _closeOpenMenu(menu: MenuStackItem | undefined) {\n    const keyManager = this._keyManager;\n    const trigger = this._openItem;\n    if (menu === trigger?.getMenuTrigger()?.getMenu()) {\n      trigger?.getMenuTrigger()?.closeMenu();\n      // If the user has moused over a sibling item we want to focus the element under mouse focus\n      // not the trigger which previously opened the now closed menu.\n      if (trigger) {\n        keyManager.setActiveItem(this._pointerTracker?.activeElement || trigger);\n      }\n    }\n  }\n\n  /** Set focus the either the current, previous or next item based on the FocusNext event. */\n  private _toggleMenuFocus(event: FocusNext | undefined) {\n    const keyManager = this._keyManager;\n    switch (event) {\n      case FocusNext.nextItem:\n        keyManager.setFocusOrigin('keyboard');\n        keyManager.setNextItemActive();\n        break;\n\n      case FocusNext.previousItem:\n        keyManager.setFocusOrigin('keyboard');\n        keyManager.setPreviousItemActive();\n        break;\n\n      case FocusNext.currentItem:\n        if (keyManager.activeItem) {\n          keyManager.setFocusOrigin('keyboard');\n          keyManager.setActiveItem(keyManager.activeItem);\n        }\n        break;\n    }\n  }\n\n  // TODO(andy9775): remove duplicate logic between menu an menu bar\n  /**\n   * Subscribe to the menu trigger's open events in order to track the trigger which opened the menu\n   * and stop tracking it when the menu is closed.\n   */\n  private _subscribeToMenuOpen() {\n    const exitCondition = merge(this._allItems.changes, this.closed);\n    this._allItems.changes\n      .pipe(\n        startWith(this._allItems),\n        mergeMap((list: QueryList<CdkMenuItem>) =>\n          list\n            .filter(item => item.hasMenu())\n            .map(item => item.getMenuTrigger()!.opened.pipe(mapTo(item), takeUntil(exitCondition))),\n        ),\n        mergeAll(),\n        switchMap((item: CdkMenuItem) => {\n          this._openItem = item;\n          return item.getMenuTrigger()!.closed;\n        }),\n        takeUntil(this.closed),\n      )\n      .subscribe(() => (this._openItem = undefined));\n  }\n\n  /** Return true if this menu has been configured in a horizontal orientation. */\n  private _isHorizontal() {\n    return this.orientation === 'horizontal';\n  }\n\n  /**\n   * Return true if this menu is an inline menu. That is, it does not exist in a pop-up and is\n   * always visible in the dom.\n   */\n  _isInline() {\n    // NoopMenuStack is the default. If this menu is not inline than the NoopMenuStack is replaced\n    // automatically.\n    return this._menuStack instanceof NoopMenuStack;\n  }\n\n  override ngOnDestroy() {\n    this._emitClosedEvent();\n    this._pointerTracker?.destroy();\n  }\n\n  /** Emit and complete the closed event emitter */\n  private _emitClosedEvent() {\n    this.closed.next();\n    this.closed.complete();\n  }\n}\n"]}

package/esm2020/menu/menu_public_index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudV9wdWJsaWNfaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9tZW51L21lbnVfcHVibGljX2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/{esm2015/menu/pointer-focus-tracker.js → esm2020/menu/pointer-focus-tracker.mjs}

@@ -46,4 +46,4 @@ export class PointerFocusTracker {
         this._destroyed.complete();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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