@angular/cdk-experimental 14.0.0-next.0 → 14.0.0-next.11

package/esm2020/menu/menu-base.mjs

@@ -0,0 +1,203 @@
+/**
+ * @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 { CdkMenuGroup } from './menu-group';
+import { ContentChildren, Directive, ElementRef, Inject, Input, NgZone, Optional, QueryList, Self, } from '@angular/core';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { CdkMenuItem } from './menu-item';
+import { merge, Subject } from 'rxjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { mapTo, mergeAll, mergeMap, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { MENU_STACK, MenuStack } 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-stack";
+/** Counter used to create unique IDs for menus. */
+let nextId = 0;
+/**
+ * Abstract directive that implements shared logic common to all menus.
+ * This class can be extended to create custom menu types.
+ */
+export class CdkMenuBase extends CdkMenuGroup {
+    constructor(
+    /** The host element. */
+    elementRef, 
+    /** The Angular zone. */
+    ngZone, 
+    /** The stack of menus this menu belongs to. */
+    menuStack, 
+    /** The menu aim service used by this menu. */
+    menuAim, 
+    /** The directionality of the current page. */
+    dir) {
+        super();
+        this.ngZone = ngZone;
+        this.menuStack = menuStack;
+        this.menuAim = menuAim;
+        this.dir = dir;
+        /** The id of the menu's host element. */
+        this.id = `cdk-menu-${nextId++}`;
+        /** The direction items in the menu flow. */
+        this.orientation = 'vertical';
+        /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+        this.isInline = false;
+        /** Emits when the MenuBar is destroyed. */
+        this.destroyed = new Subject();
+        /** Whether this menu's menu stack has focus. */
+        this._menuStackHasFocus = false;
+        this.nativeElement = elementRef.nativeElement;
+    }
+    ngAfterContentInit() {
+        if (!this.isInline) {
+            this.menuStack.push(this);
+        }
+        this._setKeyManager();
+        this._subscribeToMenuStackHasFocus();
+        this._subscribeToMenuOpen();
+        this._subscribeToMenuStackClosed();
+        this._setUpPointerTracker();
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+        this.pointerTracker?.destroy();
+    }
+    /**
+     * Place focus on the first MenuItem in the menu and set the focus origin.
+     * @param focusOrigin The origin input mode of the focus event.
+     */
+    focusFirstItem(focusOrigin = 'program') {
+        this.keyManager.setFocusOrigin(focusOrigin);
+        this.keyManager.setFirstItemActive();
+    }
+    /**
+     * Place focus on the last MenuItem in the menu and set the focus origin.
+     * @param focusOrigin The origin input mode of the focus event.
+     */
+    focusLastItem(focusOrigin = 'program') {
+        this.keyManager.setFocusOrigin(focusOrigin);
+        this.keyManager.setLastItemActive();
+    }
+    /** Gets the tabindex for this menu. */
+    _getTabIndex() {
+        const tabindexIfInline = this._menuStackHasFocus ? -1 : 0;
+        return this.isInline ? tabindexIfInline : null;
+    }
+    /**
+     * Close the open menu if the current active item opened the requested MenuStackItem.
+     * @param menu The menu requested to be closed.
+     * @param options Options to configure the behavior on close.
+     *   - `focusParentTrigger` Whether to focus the parent trigger after closing the menu.
+     */
+    closeOpenMenu(menu, options) {
+        const { focusParentTrigger } = { ...options };
+        const keyManager = this.keyManager;
+        const trigger = this.triggerItem;
+        if (menu === trigger?.getMenuTrigger()?.getMenu()) {
+            trigger?.getMenuTrigger()?.close();
+            // 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 (focusParentTrigger) {
+                if (trigger) {
+                    keyManager.setActiveItem(trigger);
+                }
+                else {
+                    keyManager.setFirstItemActive();
+                }
+            }
+        }
+    }
+    /** Setup the FocusKeyManager with the correct orientation for the menu. */
+    _setKeyManager() {
+        this.keyManager = new FocusKeyManager(this.items).withWrap().withTypeAhead().withHomeAndEnd();
+        if (this.orientation === 'horizontal') {
+            this.keyManager.withHorizontalOrientation(this.dir?.value || 'ltr');
+        }
+        else {
+            this.keyManager.withVerticalOrientation();
+        }
+    }
+    /**
+     * 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.items.changes, this.destroyed);
+        this.items.changes
+            .pipe(startWith(this.items), mergeMap((list) => list
+            .filter(item => item.hasMenu)
+            .map(item => item.getMenuTrigger().opened.pipe(mapTo(item), takeUntil(exitCondition)))), mergeAll(), switchMap((item) => {
+            this.triggerItem = item;
+            return item.getMenuTrigger().closed;
+        }), takeUntil(this.destroyed))
+            .subscribe(() => (this.triggerItem = undefined));
+    }
+    /** Subscribe to the MenuStack close events. */
+    _subscribeToMenuStackClosed() {
+        this.menuStack.closed
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(({ item, focusParentTrigger }) => this.closeOpenMenu(item, { focusParentTrigger }));
+    }
+    /** Subscribe to the MenuStack hasFocus events. */
+    _subscribeToMenuStackHasFocus() {
+        if (this.isInline) {
+            this.menuStack.hasFocus.pipe(takeUntil(this.destroyed)).subscribe(hasFocus => {
+                this._menuStackHasFocus = hasFocus;
+            });
+        }
+    }
+    /**
+     * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
+     * with the latest menu item under mouse focus.
+     */
+    _setUpPointerTracker() {
+        if (this.menuAim) {
+            this.ngZone.runOutsideAngular(() => {
+                this.pointerTracker = new PointerFocusTracker(this.items);
+            });
+            this.menuAim.initialize(this, this.pointerTracker);
+        }
+    }
+}
+CdkMenuBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuBase, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: MENU_STACK }, { token: MENU_AIM, optional: true, self: true }, { token: i1.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.13", type: CdkMenuBase, inputs: { id: "id" }, host: { attributes: { "role": "menu" }, listeners: { "focus": "focusFirstItem()", "focusin": "menuStack.setHasFocus(true)", "focusout": "menuStack.setHasFocus(false)" }, properties: { "tabindex": "_getTabIndex()", "id": "id", "attr.aria-orientation": "orientation", "attr.data-cdk-menu-stack-id": "menuStack.id" } }, queries: [{ propertyName: "items", predicate: CdkMenuItem, descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuBase, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        'role': 'menu',
+                        'class': '',
+                        '[tabindex]': '_getTabIndex()',
+                        '[id]': 'id',
+                        '[attr.aria-orientation]': 'orientation',
+                        '[attr.data-cdk-menu-stack-id]': 'menuStack.id',
+                        '(focus)': 'focusFirstItem()',
+                        '(focusin)': 'menuStack.setHasFocus(true)',
+                        '(focusout)': 'menuStack.setHasFocus(false)',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i2.MenuStack, decorators: [{
+                    type: Inject,
+                    args: [MENU_STACK]
+                }] }, { type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MENU_AIM]
+                }] }, { type: i1.Directionality, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { id: [{
+                type: Input
+            }], items: [{
+                type: ContentChildren,
+                args: [CdkMenuItem, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-base.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/menu/menu-base.ts"],"names":[],"mappings":"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","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 {CdkMenuGroup} from './menu-group';\nimport {\n  AfterContentInit,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  QueryList,\n  Self,\n} from '@angular/core';\nimport {FocusKeyManager, FocusOrigin} from '@angular/cdk/a11y';\nimport {CdkMenuItem} from './menu-item';\nimport {merge, Subject} from 'rxjs';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {mapTo, mergeAll, mergeMap, startWith, switchMap, takeUntil} from 'rxjs/operators';\nimport {MENU_STACK, MenuStack, MenuStackItem} from './menu-stack';\nimport {Menu} from './menu-interface';\nimport {PointerFocusTracker} from './pointer-focus-tracker';\nimport {MENU_AIM, MenuAim} from './menu-aim';\n\n/** Counter used to create unique IDs for menus. */\nlet nextId = 0;\n\n/**\n * Abstract directive that implements shared logic common to all menus.\n * This class can be extended to create custom menu types.\n */\n@Directive({\n  host: {\n    'role': 'menu',\n    'class': '', // reset the css class added by the super-class\n    '[tabindex]': '_getTabIndex()',\n    '[id]': 'id',\n    '[attr.aria-orientation]': 'orientation',\n    '[attr.data-cdk-menu-stack-id]': 'menuStack.id',\n    '(focus)': 'focusFirstItem()',\n    '(focusin)': 'menuStack.setHasFocus(true)',\n    '(focusout)': 'menuStack.setHasFocus(false)',\n  },\n})\nexport abstract class CdkMenuBase\n  extends CdkMenuGroup\n  implements Menu, AfterContentInit, OnDestroy\n{\n  /** The id of the menu's host element. */\n  @Input() id = `cdk-menu-${nextId++}`;\n\n  /** All child MenuItem elements nested in this Menu. */\n  @ContentChildren(CdkMenuItem, {descendants: true})\n  readonly items: QueryList<CdkMenuItem>;\n\n  /** The direction items in the menu flow. */\n  orientation: 'horizontal' | 'vertical' = 'vertical';\n\n  /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */\n  isInline = false;\n\n  /** The menu's native DOM host element. */\n  readonly nativeElement: HTMLElement;\n\n  /** Handles keyboard events for the menu. */\n  protected keyManager: FocusKeyManager<CdkMenuItem>;\n\n  /** Emits when the MenuBar is destroyed. */\n  protected readonly destroyed: Subject<void> = new Subject();\n\n  /** The Menu Item which triggered the open submenu. */\n  protected triggerItem?: CdkMenuItem;\n\n  /** Tracks the users mouse movements over the menu. */\n  protected pointerTracker?: PointerFocusTracker<CdkMenuItem>;\n\n  /** Whether this menu's menu stack has focus. */\n  private _menuStackHasFocus = false;\n\n  protected constructor(\n    /** The host element. */\n    elementRef: ElementRef<HTMLElement>,\n    /** The Angular zone. */\n    protected ngZone: NgZone,\n    /** The stack of menus this menu belongs to. */\n    @Inject(MENU_STACK) readonly menuStack: MenuStack,\n    /** The menu aim service used by this menu. */\n    @Self() @Optional() @Inject(MENU_AIM) protected readonly menuAim?: MenuAim,\n    /** The directionality of the current page. */\n    @Optional() protected readonly dir?: Directionality,\n  ) {\n    super();\n    this.nativeElement = elementRef.nativeElement;\n  }\n\n  ngAfterContentInit() {\n    if (!this.isInline) {\n      this.menuStack.push(this);\n    }\n    this._setKeyManager();\n    this._subscribeToMenuStackHasFocus();\n    this._subscribeToMenuOpen();\n    this._subscribeToMenuStackClosed();\n    this._setUpPointerTracker();\n  }\n\n  ngOnDestroy() {\n    this.destroyed.next();\n    this.destroyed.complete();\n    this.pointerTracker?.destroy();\n  }\n\n  /**\n   * Place focus on the first MenuItem in the menu and set the focus origin.\n   * @param focusOrigin The origin input mode of the focus event.\n   */\n  focusFirstItem(focusOrigin: FocusOrigin = 'program') {\n    this.keyManager.setFocusOrigin(focusOrigin);\n    this.keyManager.setFirstItemActive();\n  }\n\n  /**\n   * Place focus on the last MenuItem in the menu and set the focus origin.\n   * @param focusOrigin The origin input mode of the focus event.\n   */\n  focusLastItem(focusOrigin: FocusOrigin = 'program') {\n    this.keyManager.setFocusOrigin(focusOrigin);\n    this.keyManager.setLastItemActive();\n  }\n\n  /** Gets the tabindex for this menu. */\n  _getTabIndex() {\n    const tabindexIfInline = this._menuStackHasFocus ? -1 : 0;\n    return this.isInline ? tabindexIfInline : null;\n  }\n\n  /**\n   * Close the open menu if the current active item opened the requested MenuStackItem.\n   * @param menu The menu requested to be closed.\n   * @param options Options to configure the behavior on close.\n   *   - `focusParentTrigger` Whether to focus the parent trigger after closing the menu.\n   */\n  protected closeOpenMenu(menu: MenuStackItem, options?: {focusParentTrigger?: boolean}) {\n    const {focusParentTrigger} = {...options};\n    const keyManager = this.keyManager;\n    const trigger = this.triggerItem;\n    if (menu === trigger?.getMenuTrigger()?.getMenu()) {\n      trigger?.getMenuTrigger()?.close();\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 (focusParentTrigger) {\n        if (trigger) {\n          keyManager.setActiveItem(trigger);\n        } else {\n          keyManager.setFirstItemActive();\n        }\n      }\n    }\n  }\n\n  /** Setup the FocusKeyManager with the correct orientation for the menu. */\n  private _setKeyManager() {\n    this.keyManager = new FocusKeyManager(this.items).withWrap().withTypeAhead().withHomeAndEnd();\n\n    if (this.orientation === 'horizontal') {\n      this.keyManager.withHorizontalOrientation(this.dir?.value || 'ltr');\n    } else {\n      this.keyManager.withVerticalOrientation();\n    }\n  }\n\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.items.changes, this.destroyed);\n    this.items.changes\n      .pipe(\n        startWith(this.items),\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.triggerItem = item;\n          return item.getMenuTrigger()!.closed;\n        }),\n        takeUntil(this.destroyed),\n      )\n      .subscribe(() => (this.triggerItem = undefined));\n  }\n\n  /** Subscribe to the MenuStack close events. */\n  private _subscribeToMenuStackClosed() {\n    this.menuStack.closed\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(({item, focusParentTrigger}) => this.closeOpenMenu(item, {focusParentTrigger}));\n  }\n\n  /** Subscribe to the MenuStack hasFocus events. */\n  private _subscribeToMenuStackHasFocus() {\n    if (this.isInline) {\n      this.menuStack.hasFocus.pipe(takeUntil(this.destroyed)).subscribe(hasFocus => {\n        this._menuStackHasFocus = hasFocus;\n      });\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 _setUpPointerTracker() {\n    if (this.menuAim) {\n      this.ngZone.runOutsideAngular(() => {\n        this.pointerTracker = new PointerFocusTracker(this.items);\n      });\n      this.menuAim.initialize(this, this.pointerTracker!);\n    }\n  }\n}\n"]}

package/esm2020/menu/menu-errors.mjs

@@ -5,14 +5,6 @@
  * 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
  */
-/**
- * Throws an exception when a menu panel already has a menu stack.
- * @docs-private
- */
-export function throwExistingMenuStackError() {
-    throw Error('CdkMenuPanel is already referenced by different CdkMenuTrigger. Ensure that a menu is' +
-        ' opened by a single trigger only.');
-}
 /**
  * Throws an exception when an instance of the PointerFocusTracker is not provided.
  * @docs-private
@@ -27,4 +19,4 @@ export function throwMissingPointerFocusTracker() {
 export function throwMissingMenuReference() {
     throw Error('expected a reference to the parent menu');
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1lcnJvcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9tZW51L21lbnUtZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sVUFBVSwyQkFBMkI7SUFDekMsTUFBTSxLQUFLLENBQ1QsdUZBQXVGO1FBQ3JGLG1DQUFtQyxDQUN0QyxDQUFDO0FBQ0osQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSwrQkFBK0I7SUFDN0MsTUFBTSxLQUFLLENBQUMsNERBQTRELENBQUMsQ0FBQztBQUM1RSxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QjtJQUN2QyxNQUFNLEtBQUssQ0FBQyx5Q0FBeUMsQ0FBQyxDQUFDO0FBQ3pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBUaHJvd3MgYW4gZXhjZXB0aW9uIHdoZW4gYSBtZW51IHBhbmVsIGFscmVhZHkgaGFzIGEgbWVudSBzdGFjay5cbiAqIEBkb2NzLXByaXZhdGVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRocm93RXhpc3RpbmdNZW51U3RhY2tFcnJvcigpIHtcbiAgdGhyb3cgRXJyb3IoXG4gICAgJ0Nka01lbnVQYW5lbCBpcyBhbHJlYWR5IHJlZmVyZW5jZWQgYnkgZGlmZmVyZW50IENka01lbnVUcmlnZ2VyLiBFbnN1cmUgdGhhdCBhIG1lbnUgaXMnICtcbiAgICAgICcgb3BlbmVkIGJ5IGEgc2luZ2xlIHRyaWdnZXIgb25seS4nLFxuICApO1xufVxuXG4vKipcbiAqIFRocm93cyBhbiBleGNlcHRpb24gd2hlbiBhbiBpbnN0YW5jZSBvZiB0aGUgUG9pbnRlckZvY3VzVHJhY2tlciBpcyBub3QgcHJvdmlkZWQuXG4gKiBAZG9jcy1wcml2YXRlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0aHJvd01pc3NpbmdQb2ludGVyRm9jdXNUcmFja2VyKCkge1xuICB0aHJvdyBFcnJvcignZXhwZWN0ZWQgYW4gaW5zdGFuY2Ugb2YgUG9pbnRlckZvY3VzVHJhY2tlciB0byBiZSBwcm92aWRlZCcpO1xufVxuXG4vKipcbiAqIFRocm93cyBhbiBleGNlcHRpb24gd2hlbiBhIHJlZmVyZW5jZSB0byB0aGUgcGFyZW50IG1lbnUgaXMgbm90IHByb3ZpZGVkLlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gdGhyb3dNaXNzaW5nTWVudVJlZmVyZW5jZSgpIHtcbiAgdGhyb3cgRXJyb3IoJ2V4cGVjdGVkIGEgcmVmZXJlbmNlIHRvIHRoZSBwYXJlbnQgbWVudScpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1lcnJvcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9tZW51L21lbnUtZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sVUFBVSwrQkFBK0I7SUFDN0MsTUFBTSxLQUFLLENBQUMsNERBQTRELENBQUMsQ0FBQztBQUM1RSxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QjtJQUN2QyxNQUFNLEtBQUssQ0FBQyx5Q0FBeUMsQ0FBQyxDQUFDO0FBQ3pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBUaHJvd3MgYW4gZXhjZXB0aW9uIHdoZW4gYW4gaW5zdGFuY2Ugb2YgdGhlIFBvaW50ZXJGb2N1c1RyYWNrZXIgaXMgbm90IHByb3ZpZGVkLlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gdGhyb3dNaXNzaW5nUG9pbnRlckZvY3VzVHJhY2tlcigpIHtcbiAgdGhyb3cgRXJyb3IoJ2V4cGVjdGVkIGFuIGluc3RhbmNlIG9mIFBvaW50ZXJGb2N1c1RyYWNrZXIgdG8gYmUgcHJvdmlkZWQnKTtcbn1cblxuLyoqXG4gKiBUaHJvd3MgYW4gZXhjZXB0aW9uIHdoZW4gYSByZWZlcmVuY2UgdG8gdGhlIHBhcmVudCBtZW51IGlzIG5vdCBwcm92aWRlZC5cbiAqIEBkb2NzLXByaXZhdGVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRocm93TWlzc2luZ01lbnVSZWZlcmVuY2UoKSB7XG4gIHRocm93IEVycm9yKCdleHBlY3RlZCBhIHJlZmVyZW5jZSB0byB0aGUgcGFyZW50IG1lbnUnKTtcbn1cbiJdfQ==

package/esm2020/menu/menu-group.mjs

@@ -5,50 +5,17 @@
  * 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, Output, EventEmitter, ContentChildren, QueryList, } from '@angular/core';
+import { Directive } from '@angular/core';
 import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { takeUntil } from 'rxjs/operators';
-import { CdkMenuItemSelectable } from './menu-item-selectable';
 import * as i0 from "@angular/core";
 /**
- * Directive which acts as a grouping container for `CdkMenuItem` instances with
- * `role="menuitemradio"`, similar to a `role="radiogroup"` element.
+ * A grouping container for `CdkMenuItemRadio` instances, similar to a `role="radiogroup"` element.
  */
 export class CdkMenuGroup {
-    constructor() {
-        /** Emits the element when checkbox or radiobutton state changed  */
-        this.change = new EventEmitter();
-        /** Emits when the _selectableItems QueryList triggers a change */
-        this._selectableChanges = new EventEmitter();
-    }
-    ngAfterContentInit() {
-        this._registerMenuSelectionListeners();
-    }
-    /**
-     * Register the child selectable elements with the change emitter and ensure any new child
-     * elements do so as well.
-     */
-    _registerMenuSelectionListeners() {
-        this._selectableItems.forEach(selectable => this._registerClickListener(selectable));
-        this._selectableItems.changes.subscribe((selectableItems) => {
-            this._selectableChanges.next();
-            selectableItems.forEach(selectable => this._registerClickListener(selectable));
-        });
-    }
-    /** Register each selectable to emit on the change Emitter when clicked */
-    _registerClickListener(selectable) {
-        selectable.toggled
-            .pipe(takeUntil(this._selectableChanges))
-            .subscribe(() => this.change.next(selectable));
-    }
-    ngOnDestroy() {
-        this._selectableChanges.next();
-        this._selectableChanges.complete();
-    }
 }
-CdkMenuGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0-rc.1", ngImport: i0, type: CdkMenuGroup, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-CdkMenuGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0-rc.1", type: CdkMenuGroup, selector: "[cdkMenuGroup]", outputs: { change: "change" }, host: { attributes: { "role": "group" }, classAttribute: "cdk-menu-group" }, providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }], queries: [{ propertyName: "_selectableItems", predicate: CdkMenuItemSelectable, descendants: true }], exportAs: ["cdkMenuGroup"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0-rc.1", ngImport: i0, type: CdkMenuGroup, decorators: [{
+CdkMenuGroup.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuGroup, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuGroup.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.13", type: CdkMenuGroup, selector: "[cdkMenuGroup]", host: { attributes: { "role": "group" }, classAttribute: "cdk-menu-group" }, providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }], exportAs: ["cdkMenuGroup"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuGroup, decorators: [{
             type: Directive,
             args: [{
                     selector: '[cdkMenuGroup]',
@@ -59,10 +26,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0-rc.1", ng
                     },
                     providers: [{ provide: UniqueSelectionDispatcher, useClass: UniqueSelectionDispatcher }],
                 }]
-        }], propDecorators: { change: [{
-                type: Output
-            }], _selectableItems: [{
-                type: ContentChildren,
-                args: [CdkMenuItemSelectable, { descendants: true }]
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1ncm91cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGstZXhwZXJpbWVudGFsL21lbnUvbWVudS1ncm91cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsU0FBUyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3hDLE9BQU8sRUFBQyx5QkFBeUIsRUFBQyxNQUFNLDBCQUEwQixDQUFDOztBQUVuRTs7R0FFRztBQVVILE1BQU0sT0FBTyxZQUFZOztpSEFBWixZQUFZO3FHQUFaLFlBQVksc0hBRlosQ0FBQyxFQUFDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxRQUFRLEVBQUUseUJBQXlCLEVBQUMsQ0FBQzttR0FFM0UsWUFBWTtrQkFUeEIsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO29CQUMxQixRQUFRLEVBQUUsY0FBYztvQkFDeEIsSUFBSSxFQUFFO3dCQUNKLE1BQU0sRUFBRSxPQUFPO3dCQUNmLE9BQU8sRUFBRSxnQkFBZ0I7cUJBQzFCO29CQUNELFNBQVMsRUFBRSxDQUFDLEVBQUMsT0FBTyxFQUFFLHlCQUF5QixFQUFFLFFBQVEsRUFBRSx5QkFBeUIsRUFBQyxDQUFDO2lCQUN2RiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0RpcmVjdGl2ZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1VuaXF1ZVNlbGVjdGlvbkRpc3BhdGNoZXJ9IGZyb20gJ0Bhbmd1bGFyL2Nkay9jb2xsZWN0aW9ucyc7XG5cbi8qKlxuICogQSBncm91cGluZyBjb250YWluZXIgZm9yIGBDZGtNZW51SXRlbVJhZGlvYCBpbnN0YW5jZXMsIHNpbWlsYXIgdG8gYSBgcm9sZT1cInJhZGlvZ3JvdXBcImAgZWxlbWVudC5cbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2Nka01lbnVHcm91cF0nLFxuICBleHBvcnRBczogJ2Nka01lbnVHcm91cCcsXG4gIGhvc3Q6IHtcbiAgICAncm9sZSc6ICdncm91cCcsXG4gICAgJ2NsYXNzJzogJ2Nkay1tZW51LWdyb3VwJyxcbiAgfSxcbiAgcHJvdmlkZXJzOiBbe3Byb3ZpZGU6IFVuaXF1ZVNlbGVjdGlvbkRpc3BhdGNoZXIsIHVzZUNsYXNzOiBVbmlxdWVTZWxlY3Rpb25EaXNwYXRjaGVyfV0sXG59KVxuZXhwb3J0IGNsYXNzIENka01lbnVHcm91cCB7fVxuIl19

package/esm2020/menu/menu-interface.mjs

@@ -8,4 +8,4 @@
 import { InjectionToken } from '@angular/core';
 /** Injection token used to return classes implementing the Menu interface */
 export const CDK_MENU = new InjectionToken('cdk-menu');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9tZW51L21lbnUtaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxjQUFjLEVBQWEsTUFBTSxlQUFlLENBQUM7QUFJekQsNkVBQTZFO0FBQzdFLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBTyxVQUFVLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0luamVjdGlvblRva2VuLCBFbGVtZW50UmVmfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TWVudVN0YWNrSXRlbX0gZnJvbSAnLi9tZW51LXN0YWNrJztcbmltcG9ydCB7Rm9jdXNPcmlnaW59IGZyb20gJ0Bhbmd1bGFyL2Nkay9hMTF5JztcblxuLyoqIEluamVjdGlvbiB0b2tlbiB1c2VkIHRvIHJldHVybiBjbGFzc2VzIGltcGxlbWVudGluZyB0aGUgTWVudSBpbnRlcmZhY2UgKi9cbmV4cG9ydCBjb25zdCBDREtfTUVOVSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxNZW51PignY2RrLW1lbnUnKTtcblxuLyoqIEludGVyZmFjZSB3aGljaCBzcGVjaWZpZXMgTWVudSBvcGVyYXRpb25zIGFuZCB1c2VkIHRvIGJyZWFrIGNpcmN1bGFyIGRlcGVuZGVuY3kgaXNzdWVzICovXG5leHBvcnQgaW50ZXJmYWNlIE1lbnUgZXh0ZW5kcyBNZW51U3RhY2tJdGVtIHtcbiAgLyoqIFRoZSBlbGVtZW50IHRoZSBNZW51IGRpcmVjdGl2ZSBpcyBwbGFjZWQgb24uICovXG4gIF9lbGVtZW50UmVmOiBFbGVtZW50UmVmPEhUTUxFbGVtZW50PjtcblxuICAvKiogVGhlIG9yaWVudGF0aW9uIG9mIHRoZSBtZW51ICovXG4gIG9yaWVudGF0aW9uOiAnaG9yaXpvbnRhbCcgfCAndmVydGljYWwnO1xuXG4gIC8qKiBQbGFjZSBmb2N1cyBvbiB0aGUgZmlyc3QgTWVudUl0ZW0gaW4gdGhlIG1lbnUuICovXG4gIGZvY3VzRmlyc3RJdGVtKGZvY3VzT3JpZ2luOiBGb2N1c09yaWdpbik6IHZvaWQ7XG5cbiAgLyoqIFBsYWNlIGZvY3VzIG9uIHRoZSBsYXN0IE1lbnVJdGVtIGluIHRoZSBtZW51LiAqL1xuICBmb2N1c0xhc3RJdGVtKGZvY3VzT3JpZ2luOiBGb2N1c09yaWdpbik6IHZvaWQ7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9tZW51L21lbnUtaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFJN0MsNkVBQTZFO0FBQzdFLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBTyxVQUFVLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TWVudVN0YWNrSXRlbX0gZnJvbSAnLi9tZW51LXN0YWNrJztcbmltcG9ydCB7Rm9jdXNPcmlnaW59IGZyb20gJ0Bhbmd1bGFyL2Nkay9hMTF5JztcblxuLyoqIEluamVjdGlvbiB0b2tlbiB1c2VkIHRvIHJldHVybiBjbGFzc2VzIGltcGxlbWVudGluZyB0aGUgTWVudSBpbnRlcmZhY2UgKi9cbmV4cG9ydCBjb25zdCBDREtfTUVOVSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxNZW51PignY2RrLW1lbnUnKTtcblxuLyoqIEludGVyZmFjZSB3aGljaCBzcGVjaWZpZXMgTWVudSBvcGVyYXRpb25zIGFuZCB1c2VkIHRvIGJyZWFrIGNpcmN1bGFyIGRlcGVuZGVuY3kgaXNzdWVzICovXG5leHBvcnQgaW50ZXJmYWNlIE1lbnUgZXh0ZW5kcyBNZW51U3RhY2tJdGVtIHtcbiAgLyoqIFRoZSBpZCBvZiB0aGUgbWVudSdzIGhvc3QgZWxlbWVudC4gKi9cbiAgaWQ6IHN0cmluZztcblxuICAvKiogVGhlIG1lbnUncyBuYXRpdmUgRE9NIGhvc3QgZWxlbWVudC4gKi9cbiAgbmF0aXZlRWxlbWVudDogSFRNTEVsZW1lbnQ7XG5cbiAgLyoqIFRoZSBkaXJlY3Rpb24gaXRlbXMgaW4gdGhlIG1lbnUgZmxvdy4gKi9cbiAgcmVhZG9ubHkgb3JpZW50YXRpb246ICdob3Jpem9udGFsJyB8ICd2ZXJ0aWNhbCc7XG5cbiAgLyoqIFBsYWNlIGZvY3VzIG9uIHRoZSBmaXJzdCBNZW51SXRlbSBpbiB0aGUgbWVudS4gKi9cbiAgZm9jdXNGaXJzdEl0ZW0oZm9jdXNPcmlnaW46IEZvY3VzT3JpZ2luKTogdm9pZDtcblxuICAvKiogUGxhY2UgZm9jdXMgb24gdGhlIGxhc3QgTWVudUl0ZW0gaW4gdGhlIG1lbnUuICovXG4gIGZvY3VzTGFzdEl0ZW0oZm9jdXNPcmlnaW46IEZvY3VzT3JpZ2luKTogdm9pZDtcbn1cbiJdfQ==

package/esm2020/menu/menu-item-checkbox.mjs

@@ -14,30 +14,30 @@ import * as i0 from "@angular/core";
  * conventional checkbox.
  */
 export class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
-    /** Toggle the checked state of the checkbox. */
-    trigger() {
-        super.trigger();
+    /**
+     * Toggle the checked state of the checkbox.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options) {
+        super.trigger(options);
         if (!this.disabled) {
             this.checked = !this.checked;
         }
     }
 }
-CdkMenuItemCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0-rc.1", ngImport: i0, type: CdkMenuItemCheckbox, deps: null, target: i0.ɵɵFactoryTarget.Directive });
-CdkMenuItemCheckbox.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0-rc.1", type: CdkMenuItemCheckbox, selector: "[cdkMenuItemCheckbox]", host: { attributes: { "type": "button", "role": "menuitemcheckbox" }, properties: { "tabindex": "_tabindex", "attr.aria-checked": "checked || null", "attr.aria-disabled": "disabled || null" } }, providers: [
+CdkMenuItemCheckbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuItemCheckbox, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemCheckbox.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.13", type: CdkMenuItemCheckbox, selector: "[cdkMenuItemCheckbox]", host: { attributes: { "role": "menuitemcheckbox" } }, providers: [
         { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
         { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
     ], exportAs: ["cdkMenuItemCheckbox"], usesInheritance: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0-rc.1", ngImport: i0, type: CdkMenuItemCheckbox, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuItemCheckbox, decorators: [{
             type: Directive,
             args: [{
                     selector: '[cdkMenuItemCheckbox]',
                     exportAs: 'cdkMenuItemCheckbox',
                     host: {
-                        '[tabindex]': '_tabindex',
-                        'type': 'button',
                         'role': 'menuitemcheckbox',
-                        '[attr.aria-checked]': 'checked || null',
-                        '[attr.aria-disabled]': 'disabled || null',
                     },
                     providers: [
                         { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemCheckbox },
@@ -45,4 +45,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0-rc.1", ng
                     ],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/menu/menu-item-radio.mjs

@@ -6,71 +6,95 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { Directive, ElementRef, Self, Optional, Inject, NgZone } from '@angular/core';
+import { Directive, ElementRef, Inject, NgZone, Optional, Self } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { CdkMenuItemSelectable } from './menu-item-selectable';
 import { CdkMenuItem } from './menu-item';
-import { CdkMenuItemTrigger } from './menu-item-trigger';
+import { CdkMenuTrigger } from './menu-trigger';
 import { CDK_MENU } from './menu-interface';
 import { MENU_AIM } from './menu-aim';
+import { MENU_STACK, MenuStack } from './menu-stack';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/collections";
 import * as i2 from "@angular/cdk/bidi";
-import * as i3 from "./menu-item-trigger";
+import * as i3 from "./menu-trigger";
+import * as i4 from "./menu-stack";
+/** Counter used to set a unique id and name for a selectable item */
+let nextId = 0;
 /**
  * A directive providing behavior for the "menuitemradio" ARIA role, which behaves similarly to
  * a conventional radio-button. Any sibling `CdkMenuItemRadio` instances within the same `CdkMenu`
  * or `CdkMenuGroup` comprise a radio group with unique selection enforced.
  */
 export class CdkMenuItemRadio extends CdkMenuItemSelectable {
-    constructor(_selectionDispatcher, element, ngZone, parentMenu, menuAim, dir, 
+    constructor(
+    /** The host element for this radio item. */
+    element, 
+    /** The Angular zone. */
+    ngZone, 
+    /** The unique selection dispatcher for this radio's `CdkMenuGroup`. */
+    _selectionDispatcher, 
+    /** The menu stack this item belongs to. */
+    menuStack, 
+    /** The parent menu for this item. */
+    parentMenu, 
+    /** The menu aim used for this item. */
+    menuAim, 
+    /** The directionality of the page. */
+    dir, 
     /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
-    // `CdkMenuItemRadio` is commonly used in combination with a `CdkMenuItemTrigger`.
     // tslint:disable-next-line: lightweight-tokens
     menuTrigger) {
-        super(element, ngZone, parentMenu, menuAim, dir, menuTrigger);
+        super(element, ngZone, menuStack, parentMenu, menuAim, dir, menuTrigger);
         this._selectionDispatcher = _selectionDispatcher;
+        /** An ID to identify this radio item to the `UniqueSelectionDisptcher`. */
+        this._id = `${nextId++}`;
         this._registerDispatcherListener();
     }
-    /** Configure the unique selection dispatcher listener in order to toggle the checked state  */
-    _registerDispatcherListener() {
-        this._removeDispatcherListener = this._selectionDispatcher.listen((id, name) => (this.checked = this.id === id && this.name === name));
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._removeDispatcherListener();
     }
-    /** Toggles the checked state of the radio-button. */
-    trigger() {
-        super.trigger();
+    /**
+     * Toggles the checked state of the radio-button.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options) {
+        super.trigger(options);
         if (!this.disabled) {
-            this._selectionDispatcher.notify(this.id, this.name);
+            this._selectionDispatcher.notify(this._id, '');
         }
     }
-    ngOnDestroy() {
-        super.ngOnDestroy();
-        this._removeDispatcherListener();
+    /** Configure the unique selection dispatcher listener in order to toggle the checked state  */
+    _registerDispatcherListener() {
+        this._removeDispatcherListener = this._selectionDispatcher.listen((id) => {
+            this.checked = this._id === id;
+        });
     }
 }
-CdkMenuItemRadio.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0-rc.1", ngImport: i0, type: CdkMenuItemRadio, deps: [{ token: i1.UniqueSelectionDispatcher }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: CDK_MENU, optional: true }, { token: MENU_AIM, optional: true }, { token: i2.Directionality, optional: true }, { token: i3.CdkMenuItemTrigger, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
-CdkMenuItemRadio.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0-rc.1", type: CdkMenuItemRadio, selector: "[cdkMenuItemRadio]", host: { attributes: { "type": "button", "role": "menuitemradio" }, properties: { "tabindex": "_tabindex", "attr.aria-checked": "checked || null", "attr.aria-disabled": "disabled || null" } }, providers: [
+CdkMenuItemRadio.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuItemRadio, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.UniqueSelectionDispatcher }, { token: MENU_STACK }, { token: CDK_MENU, optional: true }, { token: MENU_AIM, optional: true }, { token: i2.Directionality, optional: true }, { token: i3.CdkMenuTrigger, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuItemRadio.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.13", type: CdkMenuItemRadio, selector: "[cdkMenuItemRadio]", host: { attributes: { "role": "menuitemradio" } }, providers: [
         { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
         { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
     ], exportAs: ["cdkMenuItemRadio"], usesInheritance: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0-rc.1", ngImport: i0, type: CdkMenuItemRadio, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.13", ngImport: i0, type: CdkMenuItemRadio, decorators: [{
             type: Directive,
             args: [{
                     selector: '[cdkMenuItemRadio]',
                     exportAs: 'cdkMenuItemRadio',
                     host: {
-                        '[tabindex]': '_tabindex',
-                        'type': 'button',
                         'role': 'menuitemradio',
-                        '[attr.aria-checked]': 'checked || null',
-                        '[attr.aria-disabled]': 'disabled || null',
                     },
                     providers: [
                         { provide: CdkMenuItemSelectable, useExisting: CdkMenuItemRadio },
                         { provide: CdkMenuItem, useExisting: CdkMenuItemSelectable },
                     ],
                 }]
-        }], ctorParameters: function () { return [{ type: i1.UniqueSelectionDispatcher }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.UniqueSelectionDispatcher }, { type: i4.MenuStack, decorators: [{
+                    type: Inject,
+                    args: [MENU_STACK]
+                }] }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
                     type: Inject,
@@ -82,9 +106,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0-rc.1", ng
                     args: [MENU_AIM]
                 }] }, { type: i2.Directionality, decorators: [{
                     type: Optional
-                }] }, { type: i3.CdkMenuItemTrigger, decorators: [{
+                }] }, { type: i3.CdkMenuTrigger, decorators: [{
                     type: Self
                 }, {
                     type: Optional
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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