@angular/cdk-experimental 14.0.0-next.6 → 14.0.0-next.9

package/menu/menu-bar.d.ts

@@ -5,13 +5,11 @@
  * 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 { AfterContentInit, OnDestroy, NgZone, ElementRef } from '@angular/core';
+import { AfterContentInit, ElementRef, NgZone, OnDestroy } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
-import { FocusOrigin } from '@angular/cdk/a11y';
-import { CdkMenuGroup } from './menu-group';
-import { Menu } from './menu-interface';
 import { MenuStack } from './menu-stack';
 import { MenuAim } from './menu-aim';
+import { CdkMenuBase } from './menu-base';
 import * as i0 from "@angular/core";
 /**
  * Directive applied to an element which configures it as a MenuBar by setting the appropriate
@@ -19,70 +17,31 @@ import * as i0 from "@angular/core";
  * this directive is applied to should contain components marked with CdkMenuItem.
  *
  */
-export declare class CdkMenuBar extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
-    readonly _menuStack: MenuStack;
+export declare class CdkMenuBar extends CdkMenuBase implements AfterContentInit, OnDestroy {
     private readonly _ngZone;
-    readonly _elementRef: ElementRef<HTMLElement>;
     private readonly _menuAim?;
-    private readonly _dir?;
-    /**
-     * Sets the aria-orientation attribute and determines where menus will be opened.
-     * Does not affect styling/layout.
-     */
-    orientation: 'horizontal' | 'vertical';
-    /** Handles keyboard events for the MenuBar. */
-    private _keyManager;
-    /** Manages items under mouse focus */
-    private _pointerTracker?;
-    /** Emits when the MenuBar is destroyed. */
-    private readonly _destroyed;
-    /** All child MenuItem elements nested in this MenuBar. */
-    private readonly _allItems;
-    /** The Menu Item which triggered the open submenu. */
-    private _openItem?;
-    constructor(_menuStack: MenuStack, _ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined);
+    readonly orientation: 'horizontal' | 'vertical';
+    menuStack: MenuStack;
+    constructor(_ngZone: NgZone, elementRef: ElementRef<HTMLElement>, menuStack: MenuStack, _menuAim?: MenuAim | undefined, dir?: Directionality);
     ngAfterContentInit(): void;
-    /** Place focus on the first MenuItem in the menu and set the focus origin. */
-    focusFirstItem(focusOrigin?: FocusOrigin): void;
-    /** Place focus on the last MenuItem in the menu and set the focus origin. */
-    focusLastItem(focusOrigin?: FocusOrigin): void;
+    ngOnDestroy(): void;
     /**
      * Handle keyboard events, specifically changing the focused element and/or toggling the active
      * items menu.
      * @param event the KeyboardEvent to handle.
      */
     _handleKeyEvent(event: KeyboardEvent): void;
-    /** Setup the FocusKeyManager with the correct orientation for the menu bar. */
-    private _setKeyManager;
     /**
      * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
      * with the latest menu item under mouse focus.
      */
     private _subscribeToMouseManager;
-    /** Subscribe to the MenuStack close and empty observables. */
-    private _subscribeToMenuStack;
-    /**
-     * Close the open menu if the current active item opened the requested MenuStackItem.
-     * @param item the MenuStackItem requested to be closed.
-     */
-    private _closeOpenMenu;
     /**
      * Set focus to either the current, previous or next item based on the FocusNext event, then
      * open the previous or next item.
      */
     private _toggleOpenMenu;
-    /**
-     * @return true if the menu bar is configured to be horizontal.
-     */
-    private _isHorizontal;
-    /**
-     * 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.
-     */
-    private _subscribeToMenuOpen;
-    /** Return true if the MenuBar has an open submenu. */
-    private _hasOpenSubmenu;
-    ngOnDestroy(): void;
+    private _subscribeToMenuStackEmptied;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], { "orientation": "cdkMenuBarOrientation"; }, {}, ["_allItems"]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], {}, {}, never>;
 }

package/menu/menu-base.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @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 { AfterContentInit, ElementRef, OnDestroy, QueryList } from '@angular/core';
+import { FocusKeyManager, FocusOrigin } from '@angular/cdk/a11y';
+import { CdkMenuItem } from './menu-item';
+import { Subject } from 'rxjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { MenuStack, MenuStackItem } from './menu-stack';
+import { Menu } from './menu-interface';
+import { PointerFocusTracker } from './pointer-focus-tracker';
+import * as i0 from "@angular/core";
+export declare abstract class CdkMenuBase extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
+    readonly _elementRef: ElementRef<HTMLElement>;
+    readonly menuStack: MenuStack;
+    protected readonly dir?: Directionality | undefined;
+    /**
+     * Sets the aria-orientation attribute and determines where menus will be opened.
+     * Does not affect styling/layout.
+     */
+    orientation: 'horizontal' | 'vertical';
+    /** All child MenuItem elements nested in this Menu. */
+    protected readonly items: QueryList<CdkMenuItem>;
+    /** Handles keyboard events for the menu. */
+    protected keyManager: FocusKeyManager<CdkMenuItem>;
+    /** Emits when the MenuBar is destroyed. */
+    protected readonly destroyed: Subject<void>;
+    /** The Menu Item which triggered the open submenu. */
+    protected openItem?: CdkMenuItem;
+    /** Manages items under mouse focus */
+    protected pointerTracker?: PointerFocusTracker<CdkMenuItem>;
+    protected constructor(_elementRef: ElementRef<HTMLElement>, menuStack: MenuStack, dir?: Directionality | undefined);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Place focus on the first MenuItem in the menu and set the focus origin. */
+    focusFirstItem(focusOrigin?: FocusOrigin): void;
+    /** Place focus on the last MenuItem in the menu and set the focus origin. */
+    focusLastItem(focusOrigin?: FocusOrigin): void;
+    /** Return true if this menu has been configured in a horizontal orientation. */
+    protected isHorizontal(): boolean;
+    /** Return true if the MenuBar has an open submenu. */
+    protected hasOpenSubmenu(): boolean;
+    /**
+     * Close the open menu if the current active item opened the requested MenuStackItem.
+     * @param item the MenuStackItem requested to be closed.
+     */
+    protected closeOpenMenu(menu: MenuStackItem | undefined): void;
+    /** Setup the FocusKeyManager with the correct orientation for the menu. */
+    private _setKeyManager;
+    /**
+     * 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.
+     */
+    private _subscribeToMenuOpen;
+    /** Subscribe to the MenuStack close and empty observables. */
+    private _subscribeToMenuStackClosed;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBase, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBase, never, never, {}, {}, ["items"]>;
+}

package/menu/menu-errors.d.ts

@@ -5,11 +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 declare function throwExistingMenuStackError(): void;
 /**
  * Throws an exception when an instance of the PointerFocusTracker is not provided.
  * @docs-private

package/menu/menu-group.d.ts

@@ -5,7 +5,7 @@
  * 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 { EventEmitter, AfterContentInit, OnDestroy } from '@angular/core';
+import { AfterContentInit, EventEmitter, OnDestroy } from '@angular/core';
 import { CdkMenuItem } from './menu-item';
 import * as i0 from "@angular/core";
 /**
@@ -20,6 +20,7 @@ export declare class CdkMenuGroup implements AfterContentInit, OnDestroy {
     /** Emits when the _selectableItems QueryList triggers a change */
     private readonly _selectableChanges;
     ngAfterContentInit(): void;
+    ngOnDestroy(): void;
     /**
      * Register the child selectable elements with the change emitter and ensure any new child
      * elements do so as well.
@@ -27,7 +28,6 @@ export declare class CdkMenuGroup implements AfterContentInit, OnDestroy {
     private _registerMenuSelectionListeners;
     /** Register each selectable to emit on the change Emitter when clicked */
     private _registerClickListener;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuGroup, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuGroup, "[cdkMenuGroup]", ["cdkMenuGroup"], {}, { "change": "change"; }, ["_selectableItems"]>;
 }

package/menu/menu-interface.d.ts

@@ -15,7 +15,7 @@ export interface Menu extends MenuStackItem {
     /** The element the Menu directive is placed on. */
     _elementRef: ElementRef<HTMLElement>;
     /** The orientation of the menu */
-    orientation: 'horizontal' | 'vertical';
+    readonly orientation: 'horizontal' | 'vertical';
     /** Place focus on the first MenuItem in the menu. */
     focusFirstItem(focusOrigin: FocusOrigin): void;
     /** Place focus on the last MenuItem in the menu. */

package/menu/menu-item-radio.d.ts

@@ -6,12 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { OnDestroy, ElementRef, NgZone } from '@angular/core';
+import { ElementRef, NgZone, OnDestroy } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { CdkMenuItemSelectable } from './menu-item-selectable';
 import { CdkMenuItemTrigger } from './menu-item-trigger';
 import { Menu } from './menu-interface';
 import { MenuAim } from './menu-aim';
+import { MenuStack } from './menu-stack';
 import * as i0 from "@angular/core";
 /**
  * A directive providing behavior for the "menuitemradio" ARIA role, which behaves similarly to
@@ -22,7 +23,7 @@ export declare class CdkMenuItemRadio extends CdkMenuItemSelectable implements O
     private readonly _selectionDispatcher;
     /** Function to unregister the selection dispatcher */
     private _removeDispatcherListener;
-    constructor(_selectionDispatcher: UniqueSelectionDispatcher, element: ElementRef<HTMLElement>, ngZone: NgZone, parentMenu?: Menu, menuAim?: MenuAim, dir?: Directionality, 
+    constructor(_selectionDispatcher: UniqueSelectionDispatcher, element: ElementRef<HTMLElement>, ngZone: NgZone, menuStack: MenuStack, parentMenu?: Menu, menuAim?: MenuAim, dir?: Directionality, 
     /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
     menuTrigger?: CdkMenuItemTrigger);
     /** Configure the unique selection dispatcher listener in order to toggle the checked state  */
@@ -30,6 +31,6 @@ export declare class CdkMenuItemRadio extends CdkMenuItemSelectable implements O
     /** Toggles the checked state of the radio-button. */
     trigger(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemRadio, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemRadio, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemRadio, "[cdkMenuItemRadio]", ["cdkMenuItemRadio"], {}, {}, never>;
 }

package/menu/menu-item-trigger.d.ts

@@ -5,13 +5,13 @@
  * 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 { EventEmitter, ElementRef, ViewContainerRef, OnDestroy, NgZone } from '@angular/core';
+import { ElementRef, Injector, NgZone, OnDestroy, ViewContainerRef } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { Overlay } from '@angular/cdk/overlay';
-import { CdkMenuPanel } from './menu-panel';
 import { Menu } from './menu-interface';
 import { MenuStack } from './menu-stack';
 import { MenuAim } from './menu-aim';
+import { MenuTrigger } from './menu-trigger';
 import * as i0 from "@angular/core";
 /**
  * Whether the target element is a menu item to be ignored by the overlay background click handler.
@@ -26,7 +26,7 @@ export declare function isClickInsideMenuOverlay(target: Element): boolean;
  * The directive must be placed along with the `cdkMenuItem` directive in order to enable full
  * functionality.
  */
-export declare class CdkMenuItemTrigger implements OnDestroy {
+export declare class CdkMenuItemTrigger extends MenuTrigger implements OnDestroy {
     private readonly _elementRef;
     protected readonly _viewContainerRef: ViewContainerRef;
     private readonly _overlay;
@@ -34,36 +34,13 @@ export declare class CdkMenuItemTrigger implements OnDestroy {
     private readonly _parentMenu?;
     private readonly _menuAim?;
     private readonly _directionality?;
-    /** Template reference variable to the menu this trigger opens */
-    get menuPanel(): CdkMenuPanel | undefined;
-    set menuPanel(panel: CdkMenuPanel | undefined);
-    /** Reference to the MenuPanel this trigger toggles. */
-    private _menuPanel?;
-    /** Emits when the attached menu is requested to open */
-    readonly opened: EventEmitter<void>;
-    /** Emits when the attached menu is requested to close */
-    readonly closed: EventEmitter<void>;
-    /** The menu stack for this trigger and its sub-menus. */
-    _menuStack: MenuStack;
-    /** A reference to the overlay which manages the triggered menu */
-    private _overlayRef;
-    /** The content of the menu panel opened by this trigger. */
-    private _panelContent;
-    /** Emits when this trigger is destroyed. */
-    private readonly _destroyed;
-    /** Emits when the outside pointer events listener on the overlay should be stopped. */
-    private readonly _stopOutsideClicksListener;
-    constructor(_elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _overlay: Overlay, _ngZone: NgZone, _parentMenu?: Menu | undefined, _menuAim?: MenuAim | undefined, _directionality?: Directionality | undefined);
+    constructor(injector: Injector, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _overlay: Overlay, _ngZone: NgZone, menuStack: MenuStack, _parentMenu?: Menu | undefined, _menuAim?: MenuAim | undefined, _directionality?: Directionality | undefined);
     /** Open/close the attached menu if the trigger has been configured with one */
     toggle(): void;
     /** Open the attached menu. */
-    openMenu(): void;
+    open(): void;
     /** Close the opened menu. */
-    closeMenu(): void;
-    /** Return true if the trigger has an attached menu */
-    hasMenu(): boolean;
-    /** Whether the menu this button is a trigger for is open */
-    isMenuOpen(): boolean;
+    close(): void;
     /**
      * Get a reference to the rendered Menu if the Menu is open and it is visible in the DOM.
      * @return the menu if it is open, otherwise undefined.
@@ -102,18 +79,11 @@ export declare class CdkMenuItemTrigger implements OnDestroy {
      * this triggers when requested.
      */
     private _registerCloseHandler;
-    /** Get the menu stack for this trigger - either from the parent or this trigger. */
-    private _getMenuStack;
-    ngOnDestroy(): void;
-    /** Set the menu panels menu stack back to null. */
-    private _resetPanelMenuStack;
     /**
      * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
      * click occurs outside the menus.
      */
     private _subscribeToOutsideClicks;
-    /** Destroy and unset the overlay reference it if exists */
-    private _destroyOverlay;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemTrigger, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "menuPanel": "cdkMenuTriggerFor"; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemTrigger, [null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "_menuTemplateRef": "cdkMenuTriggerFor"; "menuPosition": "cdkMenuPosition"; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never>;
 }

package/menu/menu-item.d.ts

@@ -11,8 +11,9 @@ import { FocusableOption } from '@angular/cdk/a11y';
 import { Directionality } from '@angular/cdk/bidi';
 import { CdkMenuItemTrigger } from './menu-item-trigger';
 import { Menu } from './menu-interface';
+import { MenuStack } from './menu-stack';
 import { FocusableElement } from './pointer-focus-tracker';
-import { Toggler, MenuAim } from './menu-aim';
+import { MenuAim, Toggler } from './menu-aim';
 import * as i0 from "@angular/core";
 /**
  * Directive which provides the ability for an element to be focused and navigated to using the
@@ -22,6 +23,7 @@ import * as i0 from "@angular/core";
 export declare class CdkMenuItem implements FocusableOption, FocusableElement, Toggler, OnDestroy {
     readonly _elementRef: ElementRef<HTMLElement>;
     private readonly _ngZone;
+    private readonly _menuStack;
     private readonly _parentMenu?;
     private readonly _menuAim?;
     private readonly _dir?;
@@ -31,6 +33,11 @@ export declare class CdkMenuItem implements FocusableOption, FocusableElement, T
     get disabled(): boolean;
     set disabled(value: BooleanInput);
     private _disabled;
+    /**
+     * The text used to locate this item during menu typeahead. If not specified,
+     * the `textContent` of the item will be used.
+     */
+    typeahead: string;
     /**
      * If this MenuItem is a regular MenuItem, outputs when it is triggered by a keyboard or mouse
      * event.
@@ -43,7 +50,7 @@ export declare class CdkMenuItem implements FocusableOption, FocusableElement, T
     _tabindex: 0 | -1;
     /** Emits when the menu item is destroyed. */
     private readonly _destroyed;
-    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone, _parentMenu?: Menu | undefined, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined, 
+    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone, _menuStack: MenuStack, _parentMenu?: Menu | undefined, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined, 
     /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
     _menuTrigger?: CdkMenuItemTrigger | undefined);
     /** Place focus on the element. */
@@ -92,9 +99,7 @@ export declare class CdkMenuItem implements FocusableOption, FocusableElement, T
      * otherwise or if no parent.
      */
     private _isParentVertical;
-    /** Get the MenuStack from the parent menu. */
-    private _getMenuStack;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItem, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItem, "[cdkMenuItem]", ["cdkMenuItem"], { "disabled": "disabled"; }, { "triggered": "cdkMenuItemTriggered"; }, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItem, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItem, "[cdkMenuItem]", ["cdkMenuItem"], { "disabled": "disabled"; "typeahead": "typeahead"; }, { "triggered": "cdkMenuItemTriggered"; }, never>;
 }

package/menu/menu-module.d.ts

@@ -1,17 +1,16 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./menu-bar";
 import * as i2 from "./menu";
-import * as i3 from "./menu-panel";
-import * as i4 from "./menu-item";
-import * as i5 from "./menu-item-radio";
-import * as i6 from "./menu-item-checkbox";
-import * as i7 from "./menu-item-trigger";
-import * as i8 from "./menu-group";
-import * as i9 from "./context-menu";
-import * as i10 from "./menu-aim";
-import * as i11 from "@angular/cdk/overlay";
+import * as i3 from "./menu-item";
+import * as i4 from "./menu-item-radio";
+import * as i5 from "./menu-item-checkbox";
+import * as i6 from "./menu-item-trigger";
+import * as i7 from "./menu-group";
+import * as i8 from "./context-menu";
+import * as i9 from "./menu-aim";
+import * as i10 from "@angular/cdk/overlay";
 export declare class CdkMenuModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuPanel, typeof i4.CdkMenuItem, typeof i5.CdkMenuItemRadio, typeof i6.CdkMenuItemCheckbox, typeof i7.CdkMenuItemTrigger, typeof i8.CdkMenuGroup, typeof i9.CdkContextMenuTrigger, typeof i10.CdkTargetMenuAim], [typeof i11.OverlayModule], [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuPanel, typeof i4.CdkMenuItem, typeof i5.CdkMenuItemRadio, typeof i6.CdkMenuItemCheckbox, typeof i7.CdkMenuItemTrigger, typeof i8.CdkMenuGroup, typeof i9.CdkContextMenuTrigger, typeof i10.CdkTargetMenuAim]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuItem, typeof i4.CdkMenuItemRadio, typeof i5.CdkMenuItemCheckbox, typeof i6.CdkMenuItemTrigger, typeof i7.CdkMenuGroup, typeof i8.CdkContextMenuTrigger, typeof i9.CdkTargetMenuAim], [typeof i10.OverlayModule], [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuItem, typeof i4.CdkMenuItemRadio, typeof i5.CdkMenuItemCheckbox, typeof i6.CdkMenuItemTrigger, typeof i7.CdkMenuGroup, typeof i8.CdkContextMenuTrigger, typeof i9.CdkTargetMenuAim]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
 }

package/menu/menu-stack.d.ts

@@ -5,7 +5,9 @@
  * 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 { InjectionToken, Optional } from '@angular/core';
 import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
 /** Events to emit as specified by the caller once the MenuStack is empty. */
 export declare const enum FocusNext {
     nextItem = 0,
@@ -17,8 +19,22 @@ export declare const enum FocusNext {
  */
 export interface MenuStackItem {
     /** A reference to the previous Menus MenuStack instance. */
-    _menuStack: MenuStack | null;
+    menuStack?: MenuStack;
 }
+/** Injection token used for an implementation of MenuStack. */
+export declare const MENU_STACK: InjectionToken<MenuStack>;
+/** A provider that provides the parent menu stack, or a new menu stack if there is no parent one. */
+export declare const PARENT_OR_NEW_MENU_STACK_PROVIDER: {
+    provide: InjectionToken<MenuStack>;
+    deps: Optional[][];
+    useFactory: (parentMenuStack?: MenuStack | undefined) => MenuStack;
+};
+/** A provider that provides the parent menu stack, or a new menu stack if there is no parent one. */
+export declare const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER: {
+    provide: InjectionToken<MenuStack>;
+    deps: Optional[][];
+    useFactory: (parentMenuStack?: MenuStack | undefined) => MenuStack;
+};
 /**
  * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off
  * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits
@@ -40,6 +56,8 @@ export declare class MenuStack {
      * perform.
      */
     readonly emptied: Observable<FocusNext | undefined>;
+    private _hasInlineMenu;
+    static inline(): MenuStack;
     /** @param menu the MenuStackItem to put on the stack. */
     push(menu: MenuStackItem): void;
     /**
@@ -70,9 +88,7 @@ export declare class MenuStack {
     length(): number;
     /** Get the top most element on the stack. */
     peek(): MenuStackItem | undefined;
-}
-/** NoopMenuStack is a placeholder MenuStack used for inline menus. */
-export declare class NoopMenuStack extends MenuStack {
-    /** Noop push - does not add elements to the MenuStack. */
-    push(_: MenuStackItem): void;
+    hasInlineMenu(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuStack, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuStack>;
 }

package/menu/menu-trigger.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @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 { EventEmitter, InjectionToken, Injector, OnDestroy, TemplateRef } from '@angular/core';
+import { Menu } from './menu-interface';
+import { MenuStack } from './menu-stack';
+import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** Injection token used for an implementation of MenuStack. */
+export declare const MENU_TRIGGER: InjectionToken<MenuTrigger>;
+export declare abstract class MenuTrigger implements OnDestroy {
+    protected injector: Injector;
+    protected menuStack: MenuStack;
+    /** A list of preferred menu positions to be used when constructing the `FlexibleConnectedPositionStrategy` for this trigger's menu. */
+    menuPosition: ConnectedPosition[];
+    /** Emits when the attached menu is requested to open */
+    readonly opened: EventEmitter<void>;
+    /** Emits when the attached menu is requested to close */
+    readonly closed: EventEmitter<void>;
+    /** Template reference variable to the menu this trigger opens */
+    protected _menuTemplateRef: TemplateRef<unknown>;
+    /** A reference to the overlay which manages the triggered menu */
+    protected _overlayRef: OverlayRef | null;
+    /** The content of the menu panel opened by this trigger. */
+    protected _menuPortal: TemplatePortal;
+    /** Emits when this trigger is destroyed. */
+    protected readonly _destroyed: Subject<void>;
+    /** Emits when the outside pointer events listener on the overlay should be stopped. */
+    protected readonly _stopOutsideClicksListener: import("rxjs").Observable<void>;
+    private _childMenuInjector?;
+    protected childMenu?: Menu;
+    protected constructor(injector: Injector, menuStack: MenuStack);
+    ngOnDestroy(): void;
+    /** Whether the attached menu is open. */
+    isOpen(): boolean;
+    registerChildMenu(child: Menu): void;
+    protected getChildMenuInjector(): Injector;
+    /** Destroy and unset the overlay reference it if exists */
+    private _destroyOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTrigger, never, never, {}, {}, never>;
+}

package/menu/menu.d.ts

@@ -5,14 +5,12 @@
  * 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 { EventEmitter, AfterContentInit, OnDestroy, OnInit, NgZone, ElementRef } from '@angular/core';
-import { FocusOrigin } from '@angular/cdk/a11y';
+import { AfterContentInit, ElementRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
-import { CdkMenuGroup } from './menu-group';
-import { CdkMenuPanel } from './menu-panel';
-import { Menu } from './menu-interface';
 import { MenuStack } from './menu-stack';
 import { MenuAim } from './menu-aim';
+import { MenuTrigger } from './menu-trigger';
+import { CdkMenuBase } from './menu-base';
 import * as i0 from "@angular/core";
 /**
  * Directive which configures the element as a Menu which should contain child elements marked as
@@ -21,55 +19,19 @@ import * as i0 from "@angular/core";
  *
  * It also acts as a RadioGroup for elements marked with role `menuitemradio`.
  */
-export declare class CdkMenu extends CdkMenuGroup implements Menu, AfterContentInit, OnInit, OnDestroy {
+export declare class CdkMenu extends CdkMenuBase implements AfterContentInit, OnDestroy {
     private readonly _ngZone;
-    readonly _elementRef: ElementRef<HTMLElement>;
+    private _parentTrigger?;
     private readonly _menuAim?;
-    private readonly _dir?;
-    private readonly _menuPanel?;
-    /**
-     * Sets the aria-orientation attribute and determines where menus will be opened.
-     * Does not affect styling/layout.
-     */
-    orientation: 'horizontal' | 'vertical';
     /** Event emitted when the menu is closed. */
-    readonly closed: EventEmitter<void | 'click' | 'tab' | 'escape'>;
-    /** Track the Menus making up the open menu stack. */
-    _menuStack: MenuStack;
-    /** Handles keyboard events for the menu. */
-    private _keyManager;
-    /** Manages items under mouse focus. */
-    private _pointerTracker?;
+    readonly closed: EventEmitter<void>;
     /** List of nested CdkMenuGroup elements */
     private readonly _nestedGroups;
-    /** All child MenuItem elements nested in this Menu. */
-    private readonly _allItems;
-    /** The Menu Item which triggered the open submenu. */
-    private _openItem?;
-    /**
-     * A reference to the enclosing parent menu panel.
-     *
-     * Required to be set when using ViewEngine since ViewEngine does support injecting a reference to
-     * the parent directive if the parent directive is placed on an `ng-template`. If using Ivy, the
-     * injected value will be used over this one.
-     */
-    private readonly _explicitPanel?;
-    constructor(_ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined, _menuPanel?: CdkMenuPanel | undefined);
-    ngOnInit(): void;
+    constructor(_ngZone: NgZone, elementRef: ElementRef<HTMLElement>, menuStack: MenuStack, _parentTrigger?: MenuTrigger | undefined, _menuAim?: MenuAim | undefined, dir?: Directionality);
     ngAfterContentInit(): void;
-    /** Place focus on the first MenuItem in the menu and set the focus origin. */
-    focusFirstItem(focusOrigin?: FocusOrigin): void;
-    /** Place focus on the last MenuItem in the menu and set the focus origin. */
-    focusLastItem(focusOrigin?: FocusOrigin): void;
+    ngOnDestroy(): void;
     /** Handle keyboard events for the Menu. */
     _handleKeyEvent(event: KeyboardEvent): void;
-    /** Register this menu with its enclosing parent menu panel */
-    private _registerWithParentPanel;
-    /**
-     * Get the enclosing CdkMenuPanel defaulting to the injected reference over the developer
-     * provided reference.
-     */
-    private _getMenuPanel;
     /**
      * 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
@@ -77,37 +39,19 @@ export declare class CdkMenu extends CdkMenuGroup implements Menu, AfterContentI
     private _completeChangeEmitter;
     /** Return true if there are nested CdkMenuGroup elements within the Menu */
     private _hasNestedGroups;
-    /** Setup the FocusKeyManager with the correct orientation for the menu. */
-    private _setKeyManager;
     /**
      * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
      * with the latest menu item under mouse focus.
      */
     private _subscribeToMouseManager;
-    /** Subscribe to the MenuStack close and empty observables. */
-    private _subscribeToMenuStack;
-    /**
-     * Close the open menu if the current active item opened the requested MenuStackItem.
-     * @param item the MenuStackItem requested to be closed.
-     */
-    private _closeOpenMenu;
     /** Set focus the either the current, previous or next item based on the FocusNext event. */
     private _toggleMenuFocus;
-    /**
-     * 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.
-     */
-    private _subscribeToMenuOpen;
-    /** Return true if this menu has been configured in a horizontal orientation. */
-    private _isHorizontal;
     /**
      * 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(): boolean;
-    ngOnDestroy(): void;
-    /** Emit and complete the closed event emitter */
-    private _emitClosedEvent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenu, [null, null, { optional: true; self: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenu, "[cdkMenu]", ["cdkMenu"], { "orientation": "cdkMenuOrientation"; "_explicitPanel": "cdkMenuPanel"; }, { "closed": "closed"; }, ["_nestedGroups", "_allItems"]>;
+    private _subscribeToMenuStackEmptied;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenu, [null, null, null, { optional: true; }, { optional: true; self: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenu, "[cdkMenu]", ["cdkMenu"], {}, { "closed": "closed"; }, ["_nestedGroups"]>;
 }

package/menu/public-api.d.ts

@@ -12,9 +12,9 @@ export * from './menu-item';
 export * from './menu-item-checkbox';
 export * from './menu-item-radio';
 export * from './menu-item-trigger';
-export * from './menu-panel';
 export * from './menu-group';
 export * from './context-menu';
-export { MenuStack, MenuStackItem } from './menu-stack';
+export * from './menu-trigger';
+export { MenuStack, MenuStackItem, MENU_STACK } from './menu-stack';
 export { CDK_MENU } from './menu-interface';
 export { TargetMenuAim, MenuAim, MENU_AIM, CdkTargetMenuAim } from './menu-aim';