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

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-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

@@ -23,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, menuStack?: MenuStack, 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  */
@@ -31,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; }, { 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,9 +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 { ElementRef, EventEmitter, Injector, NgZone, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ElementRef, Injector, NgZone, OnDestroy, ViewContainerRef } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
-import { ConnectedPosition, Overlay } from '@angular/cdk/overlay';
+import { Overlay } from '@angular/cdk/overlay';
 import { Menu } from './menu-interface';
 import { MenuStack } from './menu-stack';
 import { MenuAim } from './menu-aim';
@@ -34,33 +34,13 @@ export declare class CdkMenuItemTrigger extends MenuTrigger implements OnDestroy
     private readonly _parentMenu?;
     private readonly _menuAim?;
     private readonly _directionality?;
-    /** Template reference variable to the menu this trigger opens */
-    _menuTemplateRef?: TemplateRef<unknown>;
-    /** 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>;
-    /** A reference to the overlay which manages the triggered menu */
-    private _overlayRef;
-    /** The content of the menu panel opened by this trigger. */
-    private _menuPortal;
-    /** 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(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.
@@ -99,14 +79,11 @@ export declare class CdkMenuItemTrigger extends MenuTrigger implements OnDestroy
      * this triggers when requested.
      */
     private _registerCloseHandler;
-    ngOnDestroy(): void;
     /**
      * 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, 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

@@ -23,7 +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 _menuStack;
     private readonly _parentMenu?;
     private readonly _menuAim?;
     private readonly _dir?;
@@ -50,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, _menuStack?: MenuStack | undefined, _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. */
@@ -100,6 +100,6 @@ export declare class CdkMenuItem implements FocusableOption, FocusableElement, T
      */
     private _isParentVertical;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItem, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    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-stack.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 { InjectionToken } from '@angular/core';
+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. */
@@ -19,10 +19,22 @@ export declare const enum FocusNext {
  */
 export interface MenuStackItem {
     /** A reference to the previous Menus MenuStack instance. */
-    _menuStack?: MenuStack;
+    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
@@ -44,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;
     /**
@@ -74,6 +88,7 @@ export declare class MenuStack {
     length(): number;
     /** Get the top most element on the stack. */
     peek(): MenuStackItem | undefined;
+    hasInlineMenu(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuStack, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MenuStack>;
 }

package/menu/menu-trigger.d.ts

@@ -5,20 +5,44 @@
  * 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, Injector } from '@angular/core';
+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 class 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;
-    constructor(injector: Injector, menuStack: MenuStack);
-    protected getChildMenuInjector(): Injector;
+    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 ɵprov: i0.ɵɵInjectableDeclaration<MenuTrigger>;
+    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 { AfterContentInit, ElementRef, EventEmitter, NgZone, OnDestroy, OnInit } 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 { 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,37 +19,17 @@ 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>;
-    readonly _menuStack?: MenuStack | undefined;
     private _parentTrigger?;
     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';
     /** Event emitted when the menu is closed. */
-    readonly closed: EventEmitter<void | 'click' | 'tab' | 'escape'>;
-    /** 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?;
-    constructor(_ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _menuStack?: MenuStack | undefined, _parentTrigger?: MenuTrigger | undefined, _menuAim?: MenuAim | undefined, _dir?: Directionality | 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;
     /**
@@ -61,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; }, { optional: true; }, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenu, "[cdkMenu]", ["cdkMenu"], { "orientation": "cdkMenuOrientation"; }, { "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cdk-experimental",
-  "version": "14.0.0-next.8",
+  "version": "14.0.0-next.9",
   "description": "Experimental components for Angular CDK",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
   },
   "homepage": "https://github.com/angular/components#readme",
   "peerDependencies": {
-    "@angular/cdk": "14.0.0-next.8",
+    "@angular/cdk": "14.0.0-next.9",
     "@angular/core": "^14.0.0-0 || ^15.0.0"
   },
   "dependencies": {