@angular/cdk 14.0.0-next.11 → 14.0.0-next.12

package/menu/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export * from './public-api';

package/menu/menu-aim.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @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 { NgZone, OnDestroy, InjectionToken } from '@angular/core';
+import { PointerFocusTracker, FocusableElement } from './pointer-focus-tracker';
+import { Menu } from './menu-interface';
+import * as i0 from "@angular/core";
+/**
+ * MenuAim is responsible for determining if a sibling menuitem's menu should be closed when a
+ * Toggler item is hovered into. It is up to the hovered in item to call the MenuAim service in
+ * order to determine if it may perform its close actions.
+ */
+export interface MenuAim {
+    /**
+     * Set the Menu and its PointerFocusTracker.
+     * @param menu The menu that this menu aim service controls.
+     * @param pointerTracker The `PointerFocusTracker` for the given menu.
+     */
+    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
+    /**
+     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
+     * the submenu.
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    toggle(doToggle: () => void): void;
+}
+/** Injection token used for an implementation of MenuAim. */
+export declare const MENU_AIM: InjectionToken<MenuAim>;
+/** An element which when hovered over may open or close a menu. */
+export interface Toggler {
+    /** Gets the open menu, or undefined if no menu is open. */
+    getMenu(): Menu | undefined;
+}
+/**
+ * TargetMenuAim predicts if a user is moving into a submenu. It calculates the
+ * trajectory of the user's mouse movement in the current menu to determine if the
+ * mouse is moving towards an open submenu.
+ *
+ * The determination is made by calculating the slope of the users last NUM_POINTS moves where each
+ * pair of points determines if the trajectory line points into the submenu. It uses consensus
+ * approach by checking if at least NUM_POINTS / 2 pairs determine that the user is moving towards
+ * to submenu.
+ */
+export declare class TargetMenuAim implements MenuAim, OnDestroy {
+    /** The Angular zone. */
+    private readonly _ngZone;
+    /** The last NUM_POINTS mouse move events. */
+    private readonly _points;
+    /** Reference to the root menu in which we are tracking mouse moves. */
+    private _menu;
+    /** Reference to the root menu's mouse manager. */
+    private _pointerTracker;
+    /** The id associated with the current timeout call waiting to resolve. */
+    private _timeoutId;
+    /** Emits when this service is destroyed. */
+    private readonly _destroyed;
+    constructor(
+    /** The Angular zone. */
+    _ngZone: NgZone);
+    ngOnDestroy(): void;
+    /**
+     * Set the Menu and its PointerFocusTracker.
+     * @param menu The menu that this menu aim service controls.
+     * @param pointerTracker The `PointerFocusTracker` for the given menu.
+     */
+    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
+    /**
+     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
+     * the submenu.
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    toggle(doToggle: () => void): void;
+    /**
+     * Start the delayed toggle handler if one isn't running already.
+     *
+     * The delayed toggle handler executes the `doToggle` callback after some period of time iff the
+     * users mouse is on an item in the current menu.
+     *
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    private _startTimeout;
+    /** Whether the user is heading towards the open submenu. */
+    private _isMovingToSubmenu;
+    /** Get the bounding DOMRect for the open submenu. */
+    private _getSubmenuBounds;
+    /**
+     * Check if a reference to the PointerFocusTracker and menu element is provided.
+     * @throws an error if neither reference is provided.
+     */
+    private _checkConfigured;
+    /** Subscribe to the root menus mouse move events and update the tracked mouse points. */
+    private _subscribeToMouseMoves;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TargetMenuAim, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TargetMenuAim>;
+}
+/**
+ * CdkTargetMenuAim is a provider for the TargetMenuAim service. It can be added to an
+ * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
+ */
+export declare class CdkTargetMenuAim {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTargetMenuAim, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTargetMenuAim, "[cdkTargetMenuAim]", ["cdkTargetMenuAim"], {}, {}, never, never, false>;
+}

package/menu/menu-bar.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @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 { AfterContentInit, ElementRef, NgZone } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+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
+ * role, aria attributes, and accessible keyboard and mouse handling logic. The component that
+ * this directive is applied to should contain components marked with CdkMenuItem.
+ *
+ */
+export declare class CdkMenuBar extends CdkMenuBase implements AfterContentInit {
+    /** The direction items in the menu flow. */
+    readonly orientation = "horizontal";
+    /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+    readonly isInline = true;
+    constructor(
+    /** The host element. */
+    elementRef: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The menu stack this menu is part of. */
+    menuStack: MenuStack, 
+    /** The menu aim service used by this menu. */
+    menuAim?: MenuAim, 
+    /** The directionality of the page. */
+    dir?: Directionality);
+    ngAfterContentInit(): void;
+    /**
+     * Handle keyboard events for the Menu.
+     * @param event The keyboard event to be handled.
+     */
+    _handleKeyEvent(event: KeyboardEvent): void;
+    /**
+     * Set focus to either the current, previous or next item based on the FocusNext event, then
+     * open the previous or next item.
+     * @param focusNext The element to focus.
+     */
+    private _toggleOpenMenu;
+    /** Subscribe to the MenuStack emptied events. */
+    private _subscribeToMenuStackEmptied;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], {}, {}, never, never, false>;
+}

package/menu/menu-base.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @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, NgZone, 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 { MenuAim } from './menu-aim';
+import * as i0 from "@angular/core";
+/**
+ * Abstract directive that implements shared logic common to all menus.
+ * This class can be extended to create custom menu types.
+ */
+export declare abstract class CdkMenuBase extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
+    /** The Angular zone. */
+    protected ngZone: NgZone;
+    /** The stack of menus this menu belongs to. */
+    readonly menuStack: MenuStack;
+    /** The menu aim service used by this menu. */
+    protected readonly menuAim?: MenuAim | undefined;
+    /** The directionality of the current page. */
+    protected readonly dir?: Directionality | undefined;
+    /** The id of the menu's host element. */
+    id: string;
+    /** All child MenuItem elements nested in this Menu. */
+    readonly items: QueryList<CdkMenuItem>;
+    /** The direction items in the menu flow. */
+    orientation: 'horizontal' | 'vertical';
+    /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+    isInline: boolean;
+    /** The menu's native DOM host element. */
+    readonly nativeElement: HTMLElement;
+    /** 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 triggerItem?: CdkMenuItem;
+    /** Tracks the users mouse movements over the menu. */
+    protected pointerTracker?: PointerFocusTracker<CdkMenuItem>;
+    /** Whether this menu's menu stack has focus. */
+    private _menuStackHasFocus;
+    protected constructor(
+    /** The host element. */
+    elementRef: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The stack of menus this menu belongs to. */
+    menuStack: MenuStack, 
+    /** The menu aim service used by this menu. */
+    menuAim?: MenuAim | undefined, 
+    /** The directionality of the current page. */
+    dir?: Directionality | undefined);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * 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?: FocusOrigin): void;
+    /**
+     * 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?: FocusOrigin): void;
+    /** Gets the tabindex for this menu. */
+    _getTabIndex(): 0 | -1 | 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.
+     */
+    protected closeOpenMenu(menu: MenuStackItem, options?: {
+        focusParentTrigger?: boolean;
+    }): 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 events. */
+    private _subscribeToMenuStackClosed;
+    /** Subscribe to the MenuStack hasFocus events. */
+    private _subscribeToMenuStackHasFocus;
+    /**
+     * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
+     * with the latest menu item under mouse focus.
+     */
+    private _setUpPointerTracker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBase, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBase, never, never, { "id": "id"; }, {}, ["items"], never, false>;
+}

package/menu/menu-errors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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
+ */
+/**
+ * Throws an exception when an instance of the PointerFocusTracker is not provided.
+ * @docs-private
+ */
+export declare function throwMissingPointerFocusTracker(): void;
+/**
+ * Throws an exception when a reference to the parent menu is not provided.
+ * @docs-private
+ */
+export declare function throwMissingMenuReference(): void;

package/menu/menu-group.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+/**
+ * A grouping container for `CdkMenuItemRadio` instances, similar to a `role="radiogroup"` element.
+ */
+export declare class CdkMenuGroup {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuGroup, "[cdkMenuGroup]", ["cdkMenuGroup"], {}, {}, never, never, false>;
+}

package/menu/menu-interface.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 { InjectionToken } from '@angular/core';
+import { MenuStackItem } from './menu-stack';
+import { FocusOrigin } from '@angular/cdk/a11y';
+/** Injection token used to return classes implementing the Menu interface */
+export declare const CDK_MENU: InjectionToken<Menu>;
+/** Interface which specifies Menu operations and used to break circular dependency issues */
+export interface Menu extends MenuStackItem {
+    /** The id of the menu's host element. */
+    id: string;
+    /** The menu's native DOM host element. */
+    nativeElement: HTMLElement;
+    /** The direction items in the menu flow. */
+    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. */
+    focusLastItem(focusOrigin: FocusOrigin): void;
+}

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

@@ -0,0 +1,18 @@
+import { CdkMenuItemSelectable } from './menu-item-selectable';
+import * as i0 from "@angular/core";
+/**
+ * A directive providing behavior for the "menuitemcheckbox" ARIA role, which behaves similarly to a
+ * conventional checkbox.
+ */
+export declare class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
+    /**
+     * 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?: {
+        keepOpen: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemCheckbox, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemCheckbox, "[cdkMenuItemCheckbox]", ["cdkMenuItemCheckbox"], {}, {}, never, never, false>;
+}

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

@@ -0,0 +1,59 @@
+/**
+ * @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 { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import { ElementRef, NgZone, OnDestroy } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { CdkMenuItemSelectable } from './menu-item-selectable';
+import { CdkMenuTrigger } from './menu-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
+ * a conventional radio-button. Any sibling `CdkMenuItemRadio` instances within the same `CdkMenu`
+ * or `CdkMenuGroup` comprise a radio group with unique selection enforced.
+ */
+export declare class CdkMenuItemRadio extends CdkMenuItemSelectable implements OnDestroy {
+    /** The unique selection dispatcher for this radio's `CdkMenuGroup`. */
+    private readonly _selectionDispatcher;
+    /** An ID to identify this radio item to the `UniqueSelectionDisptcher`. */
+    private _id;
+    /** Function to unregister the selection dispatcher */
+    private _removeDispatcherListener;
+    constructor(
+    /** The host element for this radio item. */
+    element: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The unique selection dispatcher for this radio's `CdkMenuGroup`. */
+    _selectionDispatcher: UniqueSelectionDispatcher, 
+    /** The menu stack this item belongs to. */
+    menuStack: MenuStack, 
+    /** The parent menu for this item. */
+    parentMenu?: Menu, 
+    /** The menu aim used for this item. */
+    menuAim?: MenuAim, 
+    /** The directionality of the page. */
+    dir?: Directionality, 
+    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
+    menuTrigger?: CdkMenuTrigger);
+    ngOnDestroy(): void;
+    /**
+     * 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?: {
+        keepOpen: boolean;
+    }): void;
+    /** Configure the unique selection dispatcher listener in order to toggle the checked state  */
+    private _registerDispatcherListener;
+    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, never, false>;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * @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 { BooleanInput } from '@angular/cdk/coercion';
+import { CdkMenuItem } from './menu-item';
+import * as i0 from "@angular/core";
+/** Base class providing checked state for selectable MenuItems. */
+export declare abstract class CdkMenuItemSelectable extends CdkMenuItem {
+    /** Whether the element is checked */
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    private _checked;
+    /** Whether the item should close the menu if triggered by the spacebar. */
+    protected closeOnSpacebarTrigger: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemSelectable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemSelectable, never, never, { "checked": "cdkMenuItemChecked"; }, {}, never, never, false>;
+}

package/menu/menu-item.d.ts

@@ -0,0 +1,140 @@
+/**
+ * @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 { ElementRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { FocusableOption } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { Subject } from 'rxjs';
+import { CdkMenuTrigger } from './menu-trigger';
+import { Menu } from './menu-interface';
+import { MenuStack } from './menu-stack';
+import { FocusableElement } from './pointer-focus-tracker';
+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
+ * keyboard when residing in a CdkMenu, CdkMenuBar, or CdkMenuGroup. It performs user defined
+ * behavior when clicked.
+ */
+export declare class CdkMenuItem implements FocusableOption, FocusableElement, Toggler, OnDestroy {
+    /** The host element for this item. */
+    readonly _elementRef: ElementRef<HTMLElement>;
+    /** The Angular zone. */
+    private readonly _ngZone;
+    /** The menu stack this item belongs to. */
+    private readonly _menuStack;
+    /** The parent menu this item belongs to. */
+    private readonly _parentMenu?;
+    /** The menu aim service used for this item. */
+    private readonly _menuAim?;
+    /** The directionality of the page. */
+    private readonly _dir?;
+    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
+    private readonly _menuTrigger?;
+    /**  Whether the CdkMenuItem is disabled - defaults to false */
+    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.
+     */
+    typeaheadLabel: string | null;
+    /**
+     * If this MenuItem is a regular MenuItem, outputs when it is triggered by a keyboard or mouse
+     * event.
+     */
+    readonly triggered: EventEmitter<void>;
+    /** Whether the menu item opens a menu. */
+    readonly hasMenu: boolean;
+    /**
+     * The tabindex for this menu item managed internally and used for implementing roving a
+     * tab index.
+     */
+    _tabindex: 0 | -1;
+    /** Whether the item should close the menu if triggered by the spacebar. */
+    protected closeOnSpacebarTrigger: boolean;
+    /** Emits when the menu item is destroyed. */
+    protected readonly destroyed: Subject<void>;
+    constructor(
+    /** The host element for this item. */
+    _elementRef: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    _ngZone: NgZone, 
+    /** The menu stack this item belongs to. */
+    _menuStack: MenuStack, 
+    /** The parent menu this item belongs to. */
+    _parentMenu?: Menu | undefined, 
+    /** The menu aim service used for this item. */
+    _menuAim?: MenuAim | undefined, 
+    /** The directionality of the page. */
+    _dir?: Directionality | undefined, 
+    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
+    _menuTrigger?: CdkMenuTrigger | undefined);
+    ngOnDestroy(): void;
+    /** Place focus on the element. */
+    focus(): void;
+    /**
+     * If the menu item is not disabled and the element does not have a menu trigger attached, emit
+     * on the cdkMenuItemTriggered emitter and close all open menus.
+     * @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?: {
+        keepOpen: boolean;
+    }): void;
+    /** Return true if this MenuItem has an attached menu and it is open. */
+    isMenuOpen(): boolean;
+    /**
+     * 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.
+     */
+    getMenu(): Menu | undefined;
+    /** Get the CdkMenuTrigger associated with this element. */
+    getMenuTrigger(): CdkMenuTrigger | undefined;
+    /** Get the label for this element which is required by the FocusableOption interface. */
+    getLabel(): string;
+    /** Reset the tabindex to -1. */
+    _resetTabIndex(): void;
+    /**
+     * Set the tab index to 0 if not disabled and it's a focus event, or a mouse enter if this element
+     * is not in a menu bar.
+     */
+    _setTabIndex(event?: MouseEvent): void;
+    /**
+     * Handles keyboard events for the menu item, specifically either triggering the user defined
+     * callback or opening/closing the current menu based on whether the left or right arrow key was
+     * pressed.
+     * @param event the keyboard event to handle
+     */
+    _onKeydown(event: KeyboardEvent): void;
+    /** Whether this menu item is standalone or within a menu or menu bar. */
+    private _isStandaloneItem;
+    /**
+     * Handles the user pressing the back arrow key.
+     * @param event The keyboard event.
+     */
+    private _backArrowPressed;
+    /**
+     * Handles the user pressing the forward arrow key.
+     * @param event The keyboard event.
+     */
+    private _forwardArrowPressed;
+    /**
+     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
+     * into.
+     */
+    private _setupMouseEnter;
+    /**
+     * Return true if the enclosing parent menu is configured in a horizontal orientation, false
+     * otherwise or if no parent.
+     */
+    private _isParentVertical;
+    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": "cdkMenuItemDisabled"; "typeaheadLabel": "cdkMenuitemTypeaheadLabel"; }, { "triggered": "cdkMenuItemTriggered"; }, never, never, false>;
+}

package/menu/menu-module.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./menu-bar";
+import * as i2 from "./menu";
+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-trigger";
+import * as i7 from "./menu-group";
+import * as i8 from "./context-menu-trigger";
+import * as i9 from "./menu-aim";
+import * as i10 from "@angular/cdk/overlay";
+/** Module that declares components and directives for the CDK menu. */
+export declare class CdkMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuItem, typeof i4.CdkMenuItemRadio, typeof i5.CdkMenuItemCheckbox, typeof i6.CdkMenuTrigger, 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.CdkMenuTrigger, typeof i7.CdkMenuGroup, typeof i8.CdkContextMenuTrigger, typeof i9.CdkTargetMenuAim]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
+}