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

package/menu/menu-stack.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @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, Optional } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/** The relative item in the inline menu to focus after closing all popup menus. */
+export declare const enum FocusNext {
+    nextItem = 0,
+    previousItem = 1,
+    currentItem = 2
+}
+/** A single item (menu) in the menu stack. */
+export interface MenuStackItem {
+    /** A reference to the menu stack this menu stack item belongs to. */
+    menuStack?: MenuStack;
+}
+/** Injection token used for an implementation of MenuStack. */
+export declare const MENU_STACK: InjectionToken<MenuStack>;
+/** 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;
+};
+/** Provider that provides the parent menu stack, or a new inline menu stack if there is no parent one. */
+export declare const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER: (orientation: 'vertical' | 'horizontal') => {
+    provide: InjectionToken<MenuStack>;
+    deps: Optional[][];
+    useFactory: (parentMenuStack?: MenuStack | undefined) => MenuStack;
+};
+/** Options that can be provided to the close or closeAll methods. */
+export interface CloseOptions {
+    /** The element to focus next if the close operation causes the menu stack to become empty. */
+    focusNextOnEmpty?: FocusNext;
+    /** Whether to focus the parent trigger after closing the menu. */
+    focusParentTrigger?: boolean;
+}
+/** Event dispatched when a menu is closed. */
+export interface MenuStackCloseEvent {
+    /** The menu being closed. */
+    item: MenuStackItem;
+    /** Whether to focus the parent trigger after closing the menu. */
+    focusParentTrigger?: boolean;
+}
+/**
+ * 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
+ * from the `empty` observable specifying the next focus action which the listener should perform
+ * as requested by the closer.
+ */
+export declare class MenuStack {
+    /** The ID of this menu stack. */
+    readonly id: string;
+    /** All MenuStackItems tracked by this MenuStack. */
+    private readonly _elements;
+    /** Emits the element which was popped off of the stack when requested by a closer. */
+    private readonly _close;
+    /** Emits once the MenuStack has become empty after popping off elements. */
+    private readonly _empty;
+    /** Emits whether any menu in the menu stack has focus. */
+    private readonly _hasFocus;
+    /** Observable which emits the MenuStackItem which has been requested to close. */
+    readonly closed: Observable<MenuStackCloseEvent>;
+    /** Observable which emits whether any menu in the menu stack has focus. */
+    readonly hasFocus: Observable<boolean>;
+    /**
+     * Observable which emits when the MenuStack is empty after popping off the last element. It
+     * emits a FocusNext event which specifies the action the closer has requested the listener
+     * perform.
+     */
+    readonly emptied: Observable<FocusNext | undefined>;
+    /**
+     * Whether the inline menu associated with this menu stack is vertical or horizontal.
+     * `null` indicates there is no inline menu associated with this menu stack.
+     */
+    private _inlineMenuOrientation;
+    /** Creates a menu stack that originates from an inline menu. */
+    static inline(orientation: 'vertical' | 'horizontal'): MenuStack;
+    /**
+     * Adds an item to the menu stack.
+     * @param menu the MenuStackItem to put on the stack.
+     */
+    push(menu: MenuStackItem): void;
+    /**
+     * Pop items off of the stack up to and including `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the last item to pop off the stack.
+     * @param options Options that configure behavior on close.
+     */
+    close(lastItem: MenuStackItem, options?: CloseOptions): void;
+    /**
+     * Pop items off of the stack up to but excluding `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the element which should be left on the stack
+     * @return whether or not an item was removed from the stack
+     */
+    closeSubMenuOf(lastItem: MenuStackItem): boolean;
+    /**
+     * Pop off all MenuStackItems and emit each one on the `close` observable one by one.
+     * @param options Options that configure behavior on close.
+     */
+    closeAll(options?: CloseOptions): void;
+    /** Return true if this stack is empty. */
+    isEmpty(): boolean;
+    /** Return the length of the stack. */
+    length(): number;
+    /** Get the top most element on the stack. */
+    peek(): MenuStackItem | undefined;
+    /** Whether the menu stack is associated with an inline menu. */
+    hasInlineMenu(): boolean;
+    /** The orientation of the associated inline menu. */
+    inlineMenuOrientation(): "vertical" | "horizontal" | null;
+    /** Sets whether the menu stack contains the focused element. */
+    setHasFocus(hasFocus: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuStack, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuStack>;
+}

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

@@ -0,0 +1,77 @@
+/**
+ * @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, ViewContainerRef } 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<CdkMenuTriggerBase>;
+/**
+ * Abstract directive that implements shared logic common to all menu triggers.
+ * This class can be extended to create custom menu trigger types.
+ */
+export declare abstract class CdkMenuTriggerBase implements OnDestroy {
+    /** The DI injector for this component */
+    protected readonly injector: Injector;
+    /** The view container ref for this component */
+    protected readonly viewContainerRef: ViewContainerRef;
+    /** The menu stack this menu is part of. */
+    protected readonly 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 */
+    menuTemplateRef: TemplateRef<unknown>;
+    /** A reference to the overlay which manages the triggered menu */
+    protected overlayRef: OverlayRef | null;
+    /** 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>;
+    /** The child menu opened by this trigger. */
+    protected childMenu?: Menu;
+    /** The content of the menu panel opened by this trigger. */
+    private _menuPortal;
+    /** The injector to use for the child menu opened by this trigger. */
+    private _childMenuInjector?;
+    protected constructor(
+    /** The DI injector for this component */
+    injector: Injector, 
+    /** The view container ref for this component */
+    viewContainerRef: ViewContainerRef, 
+    /** The menu stack this menu is part of. */
+    menuStack: MenuStack);
+    ngOnDestroy(): void;
+    /** Whether the attached menu is open. */
+    isOpen(): boolean;
+    /** Registers a child menu as having been opened by this trigger. */
+    registerChildMenu(child: Menu): void;
+    /**
+     * Get the portal to be attached to the overlay which contains the menu. Allows for the menu
+     * content to change dynamically and be reflected in the application.
+     */
+    protected getMenuContentPortal(): TemplatePortal<any>;
+    /**
+     * Whether the given element is inside the scope of this trigger's menu stack.
+     * @param element The element to check.
+     * @return Whether the element is inside the scope of this trigger's menu stack.
+     */
+    protected isElementInsideMenuStack(element: Element): boolean;
+    /** Destroy and unset the overlay reference it if exists */
+    private _destroyOverlay;
+    /** Gets the injector to use when creating a child menu. */
+    private _getChildMenuInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuTriggerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuTriggerBase, never, never, {}, {}, never, never, false>;
+}

package/menu/menu-trigger.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 { ElementRef, Injector, NgZone, OnDestroy, ViewContainerRef } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay } from '@angular/cdk/overlay';
+import { Menu } from './menu-interface';
+import { MenuStack } from './menu-stack';
+import { MenuAim } from './menu-aim';
+import { CdkMenuTriggerBase } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+/**
+ * A directive that turns its host element into a trigger for a popup menu.
+ * It can be combined with cdkMenuItem to create sub-menus. If the element is in a top level
+ * MenuBar it will open the menu on click, or if a sibling is already opened it will open on hover.
+ * If it is inside of a Menu it will open the attached Submenu on hover regardless of its sibling
+ * state.
+ */
+export declare class CdkMenuTrigger extends CdkMenuTriggerBase implements OnDestroy {
+    /** The host element. */
+    private readonly _elementRef;
+    /** The CDK overlay service. */
+    private readonly _overlay;
+    /** The Angular zone. */
+    private readonly _ngZone;
+    /** The parent menu this trigger belongs to. */
+    private readonly _parentMenu?;
+    /** The menu aim service used by this menu. */
+    private readonly _menuAim?;
+    /** The directionality of the page. */
+    private readonly _directionality?;
+    constructor(
+    /** The DI injector for this component. */
+    injector: Injector, 
+    /** The host element. */
+    _elementRef: ElementRef<HTMLElement>, 
+    /** The view container ref for this component. */
+    viewContainerRef: ViewContainerRef, 
+    /** The CDK overlay service. */
+    _overlay: Overlay, 
+    /** The Angular zone. */
+    _ngZone: NgZone, 
+    /** The menu stack this trigger belongs to. */
+    menuStack: MenuStack, 
+    /** The parent menu this trigger belongs to. */
+    _parentMenu?: Menu | undefined, 
+    /** The menu aim service used by this menu. */
+    _menuAim?: MenuAim | undefined, 
+    /** The directionality of the page. */
+    _directionality?: Directionality | undefined);
+    /** Toggle the attached menu. */
+    toggle(): void;
+    /** Open the attached menu. */
+    open(): void;
+    /** Close the opened menu. */
+    close(): void;
+    /**
+     * Get a reference to the rendered Menu if the Menu is open and rendered in the DOM.
+     */
+    getMenu(): Menu | undefined;
+    /**
+     * Handles keyboard events for the menu item.
+     * @param event The keyboard event to handle
+     */
+    _toggleOnKeydown(event: KeyboardEvent): void;
+    /**
+     * Sets whether the trigger's menu stack has focus.
+     * @param hasFocus Whether the menu stack has focus.
+     */
+    _setHasFocus(hasFocus: boolean): void;
+    /**
+     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
+     * into.
+     */
+    private _subscribeToMouseEnter;
+    /** Close out any sibling menu trigger menus. */
+    private _closeSiblingTriggers;
+    /** Get the configuration object used to create the overlay. */
+    private _getOverlayConfig;
+    /** Build the position strategy for the overlay which specifies where to place the menu. */
+    private _getOverlayPositionStrategy;
+    /** Get the preferred positions for the opened menu relative to the menu item. */
+    private _getOverlayPositions;
+    /**
+     * Subscribe to the MenuStack close events if this is a standalone trigger and close out the menu
+     * this triggers when requested.
+     */
+    private _registerCloseHandler;
+    /**
+     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
+     * click occurs outside the menus.
+     */
+    private _subscribeToOutsideClicks;
+    /** Subscribe to the MenuStack hasFocus events. */
+    private _subscribeToMenuStackHasFocus;
+    /** Subscribe to the MenuStack closed events. */
+    private _subscribeToMenuStackClosed;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuTrigger, [null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "menuTemplateRef": "cdkMenuTriggerFor"; "menuPosition": "cdkMenuPosition"; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never, never, false>;
+}

package/menu/menu.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @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, EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { MenuStack } from './menu-stack';
+import { MenuAim } from './menu-aim';
+import { CdkMenuTriggerBase } from './menu-trigger-base';
+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
+ * CdkMenuItem or CdkMenuGroup. Sets the appropriate role and aria-attributes for a menu and
+ * contains accessible keyboard and mouse handling logic.
+ *
+ * It also acts as a RadioGroup for elements marked with role `menuitemradio`.
+ */
+export declare class CdkMenu extends CdkMenuBase implements AfterContentInit, OnDestroy {
+    /** The trigger that opened this menu. */
+    private _parentTrigger?;
+    /** Event emitted when the menu is closed. */
+    readonly closed: EventEmitter<void>;
+    /** The direction items in the menu flow. */
+    readonly orientation = "vertical";
+    /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+    readonly isInline: boolean;
+    constructor(
+    /** The host element. */
+    elementRef: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The menu stack this menu is part of. */
+    menuStack: MenuStack, 
+    /** The trigger that opened this menu. */
+    _parentTrigger?: CdkMenuTriggerBase | undefined, 
+    /** The menu aim service used by this menu. */
+    menuAim?: MenuAim, 
+    /** The directionality of the page. */
+    dir?: Directionality);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Handle keyboard events for the Menu.
+     * @param event The keyboard event to be handled.
+     */
+    _handleKeyEvent(event: KeyboardEvent): void;
+    /**
+     * Set focus the either the current, previous or next item based on the FocusNext event.
+     * @param focusNext The element to focus.
+     */
+    private _toggleMenuFocus;
+    /** Subscribe to the MenuStack emptied events. */
+    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"; }, never, never, false>;
+}

package/menu/menu_public_index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';

package/menu/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@angular/cdk/menu",
+  "fesm2020": "../fesm2020/menu.mjs",
+  "fesm2015": "../fesm2015/menu.mjs",
+  "esm2020": "../esm2020/menu/menu_public_index.mjs",
+  "typings": "./menu_public_index.d.ts",
+  "module": "../fesm2015/menu.mjs",
+  "es2020": "../fesm2020/menu.mjs"
+}

package/menu/pointer-focus-tracker.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @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, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+/** Item to track for mouse focus events. */
+export interface FocusableElement {
+    /** A reference to the element to be tracked. */
+    _elementRef: ElementRef<HTMLElement>;
+}
+/**
+ * PointerFocusTracker keeps track of the currently active item under mouse focus. It also has
+ * observables which emit when the users mouse enters and leaves a tracked element.
+ */
+export declare class PointerFocusTracker<T extends FocusableElement> {
+    /** The list of items being tracked. */
+    private readonly _items;
+    /** Emits when an element is moused into. */
+    readonly entered: Observable<T>;
+    /** Emits when an element is moused out. */
+    readonly exited: Observable<T>;
+    /** The element currently under mouse focus. */
+    activeElement?: T;
+    /** The element previously under mouse focus. */
+    previousElement?: T;
+    /** Emits when this is destroyed. */
+    private readonly _destroyed;
+    constructor(
+    /** The list of items being tracked. */
+    _items: QueryList<T>);
+    /** Stop the managers listeners. */
+    destroy(): void;
+    /**
+     * Gets a stream of pointer (mouse) entries into the given items.
+     * This should typically run outside the Angular zone.
+     */
+    private _getItemPointerEntries;
+    /**
+     * Gets a stream of pointer (mouse) exits out of the given items.
+     * This should typically run outside the Angular zone.
+     */
+    private _getItemPointerExits;
+}

package/menu/public-api.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 './menu-module';
+export * from './menu-bar';
+export * from './menu';
+export * from './menu-base';
+export * from './menu-item';
+export * from './menu-item-checkbox';
+export * from './menu-item-radio';
+export * from './menu-trigger';
+export * from './menu-group';
+export * from './menu-item-selectable';
+export * from './context-menu-trigger';
+export * from './menu-trigger-base';
+export * from './pointer-focus-tracker';
+export * from './menu-stack';
+export * from './menu-interface';
+export * from './menu-aim';

package/observers/observe-content.d.ts

@@ -78,7 +78,7 @@ export declare class CdkObserveContent implements AfterContentInit, OnDestroy {
     private _subscribe;
     private _unsubscribe;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkObserveContent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkObserveContent, "[cdkObserveContent]", ["cdkObserveContent"], { "disabled": "cdkObserveContentDisabled"; "debounce": "debounce"; }, { "event": "cdkObserveContent"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkObserveContent, "[cdkObserveContent]", ["cdkObserveContent"], { "disabled": "cdkObserveContentDisabled"; "debounce": "debounce"; }, { "event": "cdkObserveContent"; }, never, never, false>;
 }
 export declare class ObserversModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ObserversModule, never>;

package/overlay/overlay-directives.d.ts

@@ -27,7 +27,7 @@ export declare class CdkOverlayOrigin {
     /** Reference to the element on which the directive is applied. */
     elementRef: ElementRef);
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkOverlayOrigin, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOverlayOrigin, "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", ["cdkOverlayOrigin"], {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOverlayOrigin, "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", ["cdkOverlayOrigin"], {}, {}, never, never, false>;
 }
 /**
  * Directive to facilitate declarative creation of an
@@ -136,7 +136,7 @@ export declare class CdkConnectedOverlay implements OnDestroy, OnChanges {
     /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */
     private _detachOverlay;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkConnectedOverlay, [null, null, null, null, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkConnectedOverlay, "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", ["cdkConnectedOverlay"], { "origin": "cdkConnectedOverlayOrigin"; "positions": "cdkConnectedOverlayPositions"; "positionStrategy": "cdkConnectedOverlayPositionStrategy"; "offsetX": "cdkConnectedOverlayOffsetX"; "offsetY": "cdkConnectedOverlayOffsetY"; "width": "cdkConnectedOverlayWidth"; "height": "cdkConnectedOverlayHeight"; "minWidth": "cdkConnectedOverlayMinWidth"; "minHeight": "cdkConnectedOverlayMinHeight"; "backdropClass": "cdkConnectedOverlayBackdropClass"; "panelClass": "cdkConnectedOverlayPanelClass"; "viewportMargin": "cdkConnectedOverlayViewportMargin"; "scrollStrategy": "cdkConnectedOverlayScrollStrategy"; "open": "cdkConnectedOverlayOpen"; "disableClose": "cdkConnectedOverlayDisableClose"; "transformOriginSelector": "cdkConnectedOverlayTransformOriginOn"; "hasBackdrop": "cdkConnectedOverlayHasBackdrop"; "lockPosition": "cdkConnectedOverlayLockPosition"; "flexibleDimensions": "cdkConnectedOverlayFlexibleDimensions"; "growAfterOpen": "cdkConnectedOverlayGrowAfterOpen"; "push": "cdkConnectedOverlayPush"; }, { "backdropClick": "backdropClick"; "positionChange": "positionChange"; "attach": "attach"; "detach": "detach"; "overlayKeydown": "overlayKeydown"; "overlayOutsideClick": "overlayOutsideClick"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkConnectedOverlay, "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", ["cdkConnectedOverlay"], { "origin": "cdkConnectedOverlayOrigin"; "positions": "cdkConnectedOverlayPositions"; "positionStrategy": "cdkConnectedOverlayPositionStrategy"; "offsetX": "cdkConnectedOverlayOffsetX"; "offsetY": "cdkConnectedOverlayOffsetY"; "width": "cdkConnectedOverlayWidth"; "height": "cdkConnectedOverlayHeight"; "minWidth": "cdkConnectedOverlayMinWidth"; "minHeight": "cdkConnectedOverlayMinHeight"; "backdropClass": "cdkConnectedOverlayBackdropClass"; "panelClass": "cdkConnectedOverlayPanelClass"; "viewportMargin": "cdkConnectedOverlayViewportMargin"; "scrollStrategy": "cdkConnectedOverlayScrollStrategy"; "open": "cdkConnectedOverlayOpen"; "disableClose": "cdkConnectedOverlayDisableClose"; "transformOriginSelector": "cdkConnectedOverlayTransformOriginOn"; "hasBackdrop": "cdkConnectedOverlayHasBackdrop"; "lockPosition": "cdkConnectedOverlayLockPosition"; "flexibleDimensions": "cdkConnectedOverlayFlexibleDimensions"; "growAfterOpen": "cdkConnectedOverlayGrowAfterOpen"; "push": "cdkConnectedOverlayPush"; }, { "backdropClick": "backdropClick"; "positionChange": "positionChange"; "attach": "attach"; "detach": "detach"; "overlayKeydown": "overlayKeydown"; "overlayOutsideClick": "overlayOutsideClick"; }, never, never, false>;
 }
 /** @docs-private */
 export declare function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => RepositionScrollStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cdk",
-  "version": "14.0.0-next.11",
+  "version": "14.0.0-next.12",
   "description": "Angular Material Component Development Kit",
   "repository": {
     "type": "git",
@@ -100,6 +100,14 @@
       "node": "./fesm2015/collections.mjs",
       "default": "./fesm2020/collections.mjs"
     },
+    "./dialog": {
+      "types": "./dialog/dialog_public_index.d.ts",
+      "esm2020": "./esm2020/dialog/dialog_public_index.mjs",
+      "es2020": "./fesm2020/dialog.mjs",
+      "es2015": "./fesm2015/dialog.mjs",
+      "node": "./fesm2015/dialog.mjs",
+      "default": "./fesm2020/dialog.mjs"
+    },
     "./drag-drop": {
       "types": "./drag-drop/drag-drop_public_index.d.ts",
       "esm2020": "./esm2020/drag-drop/drag-drop_public_index.mjs",
@@ -124,6 +132,14 @@
       "node": "./fesm2015/layout.mjs",
       "default": "./fesm2020/layout.mjs"
     },
+    "./menu": {
+      "types": "./menu/menu_public_index.d.ts",
+      "esm2020": "./esm2020/menu/menu_public_index.mjs",
+      "es2020": "./fesm2020/menu.mjs",
+      "es2015": "./fesm2015/menu.mjs",
+      "node": "./fesm2015/menu.mjs",
+      "default": "./fesm2020/menu.mjs"
+    },
     "./observers": {
       "types": "./observers/observers_public_index.d.ts",
       "esm2020": "./esm2020/observers/observers_public_index.mjs",

package/portal/portal-directives.d.ts

@@ -15,7 +15,7 @@ import * as i0 from "@angular/core";
 export declare class CdkPortal extends TemplatePortal {
     constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkPortal, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkPortal, "[cdkPortal]", ["cdkPortal"], {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkPortal, "[cdkPortal]", ["cdkPortal"], {}, {}, never, never, false>;
 }
 /**
  * @deprecated Use `CdkPortal` instead.
@@ -23,7 +23,7 @@ export declare class CdkPortal extends TemplatePortal {
  */
 export declare class TemplatePortalDirective extends CdkPortal {
     static ɵfac: i0.ɵɵFactoryDeclaration<TemplatePortalDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplatePortalDirective, "[cdk-portal], [portal]", ["cdkPortal"], {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplatePortalDirective, "[cdk-portal], [portal]", ["cdkPortal"], {}, {}, never, never, false>;
 }
 /**
  * Possible attached references to the CdkPortalOutlet.
@@ -82,7 +82,7 @@ export declare class CdkPortalOutlet extends BasePortalOutlet implements OnInit,
     /** Gets the root node of the portal outlet. */
     private _getRootNode;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkPortalOutlet, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkPortalOutlet, "[cdkPortalOutlet]", ["cdkPortalOutlet"], { "portal": "cdkPortalOutlet"; }, { "attached": "attached"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkPortalOutlet, "[cdkPortalOutlet]", ["cdkPortalOutlet"], { "portal": "cdkPortalOutlet"; }, { "attached": "attached"; }, never, never, false>;
 }
 /**
  * @deprecated Use `CdkPortalOutlet` instead.
@@ -90,7 +90,7 @@ export declare class CdkPortalOutlet extends BasePortalOutlet implements OnInit,
  */
 export declare class PortalHostDirective extends CdkPortalOutlet {
     static ɵfac: i0.ɵɵFactoryDeclaration<PortalHostDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalHostDirective, "[cdkPortalHost], [portalHost]", ["cdkPortalHost"], { "portal": "cdkPortalHost"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalHostDirective, "[cdkPortalHost], [portalHost]", ["cdkPortalHost"], { "portal": "cdkPortalHost"; }, {}, never, never, false>;
 }
 export declare class PortalModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<PortalModule, never>;

package/schematics/ng-add/index.js

@@ -28,7 +28,7 @@ function default_1() {
             // In order to align the CDK version with other Angular dependencies that are setup by
             // `@schematics/angular`, we use tilde instead of caret. This is default for Angular
             // dependencies in new CLI projects.
-            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-next.11`);
+            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-next.12`);
             // Add a task to run the package manager. This is necessary because we updated the
             // workspace "package.json" file and we want lock files to reflect the new version range.
             context.addTask(new tasks_1.NodePackageInstallTask());

package/schematics/ng-add/index.mjs

@@ -28,7 +28,7 @@ function default_1() {
             // In order to align the CDK version with other Angular dependencies that are setup by
             // `@schematics/angular`, we use tilde instead of caret. This is default for Angular
             // dependencies in new CLI projects.
-            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-next.11`);
+            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~14.0.0-next.12`);
             // Add a task to run the package manager. This is necessary because we updated the
             // workspace "package.json" file and we want lock files to reflect the new version range.
             context.addTask(new tasks_1.NodePackageInstallTask());

package/scrolling/fixed-size-virtual-scroll.d.ts

@@ -93,5 +93,5 @@ export declare class CdkFixedSizeVirtualScroll implements OnChanges {
     _scrollStrategy: FixedSizeVirtualScrollStrategy;
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkFixedSizeVirtualScroll, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkFixedSizeVirtualScroll, "cdk-virtual-scroll-viewport[itemSize]", never, { "itemSize": "itemSize"; "minBufferPx": "minBufferPx"; "maxBufferPx": "maxBufferPx"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkFixedSizeVirtualScroll, "cdk-virtual-scroll-viewport[itemSize]", never, { "itemSize": "itemSize"; "minBufferPx": "minBufferPx"; "maxBufferPx": "maxBufferPx"; }, {}, never, never, false>;
 }

package/scrolling/scrollable.d.ts

@@ -81,5 +81,5 @@ export declare class CdkScrollable implements OnInit, OnDestroy {
      */
     measureScrollOffset(from: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkScrollable, [null, null, null, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkScrollable, "[cdk-scrollable], [cdkScrollable]", never, {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkScrollable, "[cdk-scrollable], [cdkScrollable]", never, {}, {}, never, never, false>;
 }

package/scrolling/virtual-for-of.d.ts

@@ -113,5 +113,5 @@ export declare class CdkVirtualForOf<T> implements CdkVirtualScrollRepeater<T>,
     private _updateComputedContextProperties;
     private _getEmbeddedViewArgs;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkVirtualForOf<any>, [null, null, null, null, { skipSelf: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkVirtualForOf<any>, "[cdkVirtualFor][cdkVirtualForOf]", never, { "cdkVirtualForOf": "cdkVirtualForOf"; "cdkVirtualForTrackBy": "cdkVirtualForTrackBy"; "cdkVirtualForTemplate": "cdkVirtualForTemplate"; "cdkVirtualForTemplateCacheSize": "cdkVirtualForTemplateCacheSize"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkVirtualForOf<any>, "[cdkVirtualFor][cdkVirtualForOf]", never, { "cdkVirtualForOf": "cdkVirtualForOf"; "cdkVirtualForTrackBy": "cdkVirtualForTrackBy"; "cdkVirtualForTemplate": "cdkVirtualForTemplate"; "cdkVirtualForTemplateCacheSize": "cdkVirtualForTemplateCacheSize"; }, {}, never, never, false>;
 }

package/scrolling/virtual-scroll-viewport.d.ts

@@ -143,5 +143,5 @@ export declare class CdkVirtualScrollViewport extends CdkScrollable implements O
     /** Calculates the `style.width` and `style.height` for the spacer element. */
     private _calculateSpacerSize;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkVirtualScrollViewport, [null, null, null, { optional: true; }, { optional: true; }, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CdkVirtualScrollViewport, "cdk-virtual-scroll-viewport", never, { "orientation": "orientation"; "appendOnly": "appendOnly"; }, { "scrolledIndexChange": "scrolledIndexChange"; }, never, ["*"]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CdkVirtualScrollViewport, "cdk-virtual-scroll-viewport", never, { "orientation": "orientation"; "appendOnly": "appendOnly"; }, { "scrolledIndexChange": "scrolledIndexChange"; }, never, ["*"], false>;
 }

package/stepper/step-header.d.ts

@@ -14,5 +14,5 @@ export declare class CdkStepHeader implements FocusableOption {
     /** Focuses the step header. */
     focus(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkStepHeader, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkStepHeader, "[cdkStepHeader]", never, {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkStepHeader, "[cdkStepHeader]", never, {}, {}, never, never, false>;
 }

package/stepper/step-label.d.ts

@@ -11,5 +11,5 @@ export declare class CdkStepLabel {
     template: TemplateRef<any>;
     constructor(/** @docs-private */ template: TemplateRef<any>);
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkStepLabel, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkStepLabel, "[cdkStepLabel]", never, {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkStepLabel, "[cdkStepLabel]", never, {}, {}, never, never, false>;
 }