@angular/cdk 14.0.0-next.7 → 14.0.0-rc.0

package/esm2020/menu/menu-trigger.mjs

@@ -0,0 +1,304 @@
+/**
+ * @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 { Directive, ElementRef, Inject, Injector, NgZone, Optional, ViewContainerRef, } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay, OverlayConfig, STANDARD_DROPDOWN_ADJACENT_POSITIONS, STANDARD_DROPDOWN_BELOW_POSITIONS, } from '@angular/cdk/overlay';
+import { DOWN_ARROW, ENTER, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';
+import { fromEvent } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { CDK_MENU } from './menu-interface';
+import { MENU_STACK, MenuStack, PARENT_OR_NEW_MENU_STACK_PROVIDER } from './menu-stack';
+import { MENU_AIM } from './menu-aim';
+import { CdkMenuTriggerBase, MENU_TRIGGER } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/cdk/bidi";
+import * as i3 from "./menu-stack";
+/**
+ * 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 class CdkMenuTrigger extends CdkMenuTriggerBase {
+    constructor(
+    /** The DI injector for this component. */
+    injector, 
+    /** The host element. */
+    _elementRef, 
+    /** The view container ref for this component. */
+    viewContainerRef, 
+    /** The CDK overlay service. */
+    _overlay, 
+    /** The Angular zone. */
+    _ngZone, 
+    /** The menu stack this trigger belongs to. */
+    menuStack, 
+    /** The parent menu this trigger belongs to. */
+    _parentMenu, 
+    /** The menu aim service used by this menu. */
+    _menuAim, 
+    /** The directionality of the page. */
+    _directionality) {
+        super(injector, viewContainerRef, menuStack);
+        this._elementRef = _elementRef;
+        this._overlay = _overlay;
+        this._ngZone = _ngZone;
+        this._parentMenu = _parentMenu;
+        this._menuAim = _menuAim;
+        this._directionality = _directionality;
+        this._registerCloseHandler();
+        this._subscribeToMenuStackClosed();
+        this._subscribeToMouseEnter();
+        this._subscribeToMenuStackHasFocus();
+    }
+    /** Toggle the attached menu. */
+    toggle() {
+        this.isOpen() ? this.close() : this.open();
+    }
+    /** Open the attached menu. */
+    open() {
+        if (!this.isOpen()) {
+            this.opened.next();
+            this.overlayRef = this.overlayRef || this._overlay.create(this._getOverlayConfig());
+            this.overlayRef.attach(this.getMenuContentPortal());
+            this._subscribeToOutsideClicks();
+        }
+    }
+    /** Close the opened menu. */
+    close() {
+        if (this.isOpen()) {
+            this.closed.next();
+            this.overlayRef.detach();
+        }
+        this._closeSiblingTriggers();
+    }
+    /**
+     * Get a reference to the rendered Menu if the Menu is open and rendered in the DOM.
+     */
+    getMenu() {
+        return this.childMenu;
+    }
+    /**
+     * Handles keyboard events for the menu item.
+     * @param event The keyboard event to handle
+     */
+    _toggleOnKeydown(event) {
+        const isParentVertical = this._parentMenu?.orientation === 'vertical';
+        const keyCode = event.keyCode;
+        switch (keyCode) {
+            case SPACE:
+            case ENTER:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.toggle();
+                    this.childMenu?.focusFirstItem('keyboard');
+                }
+                break;
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && isParentVertical && this._directionality?.value !== 'rtl') {
+                        event.preventDefault();
+                        this.open();
+                        this.childMenu?.focusFirstItem('keyboard');
+                    }
+                }
+                break;
+            case LEFT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && isParentVertical && this._directionality?.value === 'rtl') {
+                        event.preventDefault();
+                        this.open();
+                        this.childMenu?.focusFirstItem('keyboard');
+                    }
+                }
+                break;
+            case DOWN_ARROW:
+            case UP_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (!isParentVertical) {
+                        event.preventDefault();
+                        this.open();
+                        keyCode === DOWN_ARROW
+                            ? this.childMenu?.focusFirstItem('keyboard')
+                            : this.childMenu?.focusLastItem('keyboard');
+                    }
+                }
+                break;
+        }
+    }
+    /**
+     * Sets whether the trigger's menu stack has focus.
+     * @param hasFocus Whether the menu stack has focus.
+     */
+    _setHasFocus(hasFocus) {
+        if (!this._parentMenu) {
+            this.menuStack.setHasFocus(hasFocus);
+        }
+    }
+    /**
+     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
+     * into.
+     */
+    _subscribeToMouseEnter() {
+        // Closes any sibling menu items and opens the menu associated with this trigger.
+        const toggleMenus = () => this._ngZone.run(() => {
+            this._closeSiblingTriggers();
+            this.open();
+        });
+        this._ngZone.runOutsideAngular(() => {
+            fromEvent(this._elementRef.nativeElement, 'mouseenter')
+                .pipe(filter(() => !this.menuStack.isEmpty() && !this.isOpen()), takeUntil(this.destroyed))
+                .subscribe(() => {
+                if (this._menuAim) {
+                    this._menuAim.toggle(toggleMenus);
+                }
+                else {
+                    toggleMenus();
+                }
+            });
+        });
+    }
+    /** Close out any sibling menu trigger menus. */
+    _closeSiblingTriggers() {
+        if (this._parentMenu) {
+            // If nothing was removed from the stack and the last element is not the parent item
+            // that means that the parent menu is a menu bar since we don't put the menu bar on the
+            // stack
+            const isParentMenuBar = !this.menuStack.closeSubMenuOf(this._parentMenu) &&
+                this.menuStack.peek() !== this._parentMenu;
+            if (isParentMenuBar) {
+                this.menuStack.closeAll();
+            }
+        }
+        else {
+            this.menuStack.closeAll();
+        }
+    }
+    /** Get the configuration object used to create the overlay. */
+    _getOverlayConfig() {
+        return new OverlayConfig({
+            positionStrategy: this._getOverlayPositionStrategy(),
+            scrollStrategy: this._overlay.scrollStrategies.reposition(),
+            direction: this._directionality,
+        });
+    }
+    /** Build the position strategy for the overlay which specifies where to place the menu. */
+    _getOverlayPositionStrategy() {
+        return this._overlay
+            .position()
+            .flexibleConnectedTo(this._elementRef)
+            .withLockedPosition()
+            .withGrowAfterOpen()
+            .withPositions(this._getOverlayPositions());
+    }
+    /** Get the preferred positions for the opened menu relative to the menu item. */
+    _getOverlayPositions() {
+        return (this.menuPosition ??
+            (!this._parentMenu || this._parentMenu.orientation === 'horizontal'
+                ? STANDARD_DROPDOWN_BELOW_POSITIONS
+                : STANDARD_DROPDOWN_ADJACENT_POSITIONS));
+    }
+    /**
+     * Subscribe to the MenuStack close events if this is a standalone trigger and close out the menu
+     * this triggers when requested.
+     */
+    _registerCloseHandler() {
+        if (!this._parentMenu) {
+            this.menuStack.closed.pipe(takeUntil(this.destroyed)).subscribe(({ item }) => {
+                if (item === this.childMenu) {
+                    this.close();
+                }
+            });
+        }
+    }
+    /**
+     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
+     * click occurs outside the menus.
+     */
+    _subscribeToOutsideClicks() {
+        if (this.overlayRef) {
+            this.overlayRef
+                .outsidePointerEvents()
+                .pipe(filter(e => e.target != this._elementRef.nativeElement &&
+                !this._elementRef.nativeElement.contains(e.target)), takeUntil(this.stopOutsideClicksListener))
+                .subscribe(event => {
+                if (!this.isElementInsideMenuStack(event.target)) {
+                    this.menuStack.closeAll();
+                }
+                else {
+                    this._closeSiblingTriggers();
+                }
+            });
+        }
+    }
+    /** Subscribe to the MenuStack hasFocus events. */
+    _subscribeToMenuStackHasFocus() {
+        if (!this._parentMenu) {
+            this.menuStack.hasFocus.pipe(takeUntil(this.destroyed)).subscribe(hasFocus => {
+                if (!hasFocus) {
+                    this.menuStack.closeAll();
+                }
+            });
+        }
+    }
+    /** Subscribe to the MenuStack closed events. */
+    _subscribeToMenuStackClosed() {
+        if (!this._parentMenu) {
+            this.menuStack.closed.subscribe(({ focusParentTrigger }) => {
+                if (focusParentTrigger && !this.menuStack.length()) {
+                    this._elementRef.nativeElement.focus();
+                }
+            });
+        }
+    }
+}
+CdkMenuTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.16", ngImport: i0, type: CdkMenuTrigger, deps: [{ token: i0.Injector }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.Overlay }, { token: i0.NgZone }, { token: MENU_STACK }, { token: CDK_MENU, optional: true }, { token: MENU_AIM, optional: true }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.0-next.16", type: CdkMenuTrigger, selector: "[cdkMenuTriggerFor]", inputs: { menuTemplateRef: ["cdkMenuTriggerFor", "menuTemplateRef"], menuPosition: ["cdkMenuPosition", "menuPosition"] }, outputs: { opened: "cdkMenuOpened", closed: "cdkMenuClosed" }, host: { attributes: { "aria-haspopup": "menu" }, listeners: { "focusin": "_setHasFocus(true)", "focusout": "_setHasFocus(false)", "keydown": "_toggleOnKeydown($event)", "click": "toggle()" }, properties: { "attr.aria-expanded": "isOpen()" }, classAttribute: "cdk-menu-trigger" }, providers: [
+        { provide: MENU_TRIGGER, useExisting: CdkMenuTrigger },
+        PARENT_OR_NEW_MENU_STACK_PROVIDER,
+    ], exportAs: ["cdkMenuTriggerFor"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.16", ngImport: i0, type: CdkMenuTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuTriggerFor]',
+                    exportAs: 'cdkMenuTriggerFor',
+                    host: {
+                        'class': 'cdk-menu-trigger',
+                        'aria-haspopup': 'menu',
+                        '[attr.aria-expanded]': 'isOpen()',
+                        '(focusin)': '_setHasFocus(true)',
+                        '(focusout)': '_setHasFocus(false)',
+                        '(keydown)': '_toggleOnKeydown($event)',
+                        '(click)': 'toggle()',
+                    },
+                    inputs: ['menuTemplateRef: cdkMenuTriggerFor', 'menuPosition: cdkMenuPosition'],
+                    outputs: ['opened: cdkMenuOpened', 'closed: cdkMenuClosed'],
+                    providers: [
+                        { provide: MENU_TRIGGER, useExisting: CdkMenuTrigger },
+                        PARENT_OR_NEW_MENU_STACK_PROVIDER,
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.Overlay }, { type: i0.NgZone }, { type: i3.MenuStack, decorators: [{
+                    type: Inject,
+                    args: [MENU_STACK]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CDK_MENU]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MENU_AIM]
+                }] }, { type: i2.Directionality, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-trigger.js","sourceRoot":"","sources":["../../../../../../src/cdk/menu/menu-trigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Directive,\n  ElementRef,\n  Inject,\n  Injector,\n  NgZone,\n  OnDestroy,\n  Optional,\n  ViewContainerRef,\n} from '@angular/core';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {\n  ConnectedPosition,\n  FlexibleConnectedPositionStrategy,\n  Overlay,\n  OverlayConfig,\n  STANDARD_DROPDOWN_ADJACENT_POSITIONS,\n  STANDARD_DROPDOWN_BELOW_POSITIONS,\n} from '@angular/cdk/overlay';\nimport {\n  DOWN_ARROW,\n  ENTER,\n  hasModifierKey,\n  LEFT_ARROW,\n  RIGHT_ARROW,\n  SPACE,\n  UP_ARROW,\n} from '@angular/cdk/keycodes';\nimport {fromEvent} from 'rxjs';\nimport {filter, takeUntil} from 'rxjs/operators';\nimport {CDK_MENU, Menu} from './menu-interface';\nimport {MENU_STACK, MenuStack, PARENT_OR_NEW_MENU_STACK_PROVIDER} from './menu-stack';\nimport {MENU_AIM, MenuAim} from './menu-aim';\nimport {CdkMenuTriggerBase, MENU_TRIGGER} from './menu-trigger-base';\n\n/**\n * A directive that turns its host element into a trigger for a popup menu.\n * It can be combined with cdkMenuItem to create sub-menus. If the element is in a top level\n * MenuBar it will open the menu on click, or if a sibling is already opened it will open on hover.\n * If it is inside of a Menu it will open the attached Submenu on hover regardless of its sibling\n * state.\n */\n@Directive({\n  selector: '[cdkMenuTriggerFor]',\n  exportAs: 'cdkMenuTriggerFor',\n  host: {\n    'class': 'cdk-menu-trigger',\n    'aria-haspopup': 'menu',\n    '[attr.aria-expanded]': 'isOpen()',\n    '(focusin)': '_setHasFocus(true)',\n    '(focusout)': '_setHasFocus(false)',\n    '(keydown)': '_toggleOnKeydown($event)',\n    '(click)': 'toggle()',\n  },\n  inputs: ['menuTemplateRef: cdkMenuTriggerFor', 'menuPosition: cdkMenuPosition'],\n  outputs: ['opened: cdkMenuOpened', 'closed: cdkMenuClosed'],\n  providers: [\n    {provide: MENU_TRIGGER, useExisting: CdkMenuTrigger},\n    PARENT_OR_NEW_MENU_STACK_PROVIDER,\n  ],\n})\nexport class CdkMenuTrigger extends CdkMenuTriggerBase implements OnDestroy {\n  constructor(\n    /** The DI injector for this component. */\n    injector: Injector,\n    /** The host element. */\n    private readonly _elementRef: ElementRef<HTMLElement>,\n    /** The view container ref for this component. */\n    viewContainerRef: ViewContainerRef,\n    /** The CDK overlay service. */\n    private readonly _overlay: Overlay,\n    /** The Angular zone. */\n    private readonly _ngZone: NgZone,\n    /** The menu stack this trigger belongs to. */\n    @Inject(MENU_STACK) menuStack: MenuStack,\n    /** The parent menu this trigger belongs to. */\n    @Optional() @Inject(CDK_MENU) private readonly _parentMenu?: Menu,\n    /** The menu aim service used by this menu. */\n    @Optional() @Inject(MENU_AIM) private readonly _menuAim?: MenuAim,\n    /** The directionality of the page. */\n    @Optional() private readonly _directionality?: Directionality,\n  ) {\n    super(injector, viewContainerRef, menuStack);\n    this._registerCloseHandler();\n    this._subscribeToMenuStackClosed();\n    this._subscribeToMouseEnter();\n    this._subscribeToMenuStackHasFocus();\n  }\n\n  /** Toggle the attached menu. */\n  toggle() {\n    this.isOpen() ? this.close() : this.open();\n  }\n\n  /** Open the attached menu. */\n  open() {\n    if (!this.isOpen()) {\n      this.opened.next();\n\n      this.overlayRef = this.overlayRef || this._overlay.create(this._getOverlayConfig());\n      this.overlayRef.attach(this.getMenuContentPortal());\n      this._subscribeToOutsideClicks();\n    }\n  }\n\n  /** Close the opened menu. */\n  close() {\n    if (this.isOpen()) {\n      this.closed.next();\n\n      this.overlayRef!.detach();\n    }\n    this._closeSiblingTriggers();\n  }\n\n  /**\n   * Get a reference to the rendered Menu if the Menu is open and rendered in the DOM.\n   */\n  getMenu(): Menu | undefined {\n    return this.childMenu;\n  }\n\n  /**\n   * Handles keyboard events for the menu item.\n   * @param event The keyboard event to handle\n   */\n  _toggleOnKeydown(event: KeyboardEvent) {\n    const isParentVertical = this._parentMenu?.orientation === 'vertical';\n    const keyCode = event.keyCode;\n    switch (keyCode) {\n      case SPACE:\n      case ENTER:\n        if (!hasModifierKey(event)) {\n          event.preventDefault();\n          this.toggle();\n          this.childMenu?.focusFirstItem('keyboard');\n        }\n        break;\n\n      case RIGHT_ARROW:\n        if (!hasModifierKey(event)) {\n          if (this._parentMenu && isParentVertical && this._directionality?.value !== 'rtl') {\n            event.preventDefault();\n            this.open();\n            this.childMenu?.focusFirstItem('keyboard');\n          }\n        }\n        break;\n\n      case LEFT_ARROW:\n        if (!hasModifierKey(event)) {\n          if (this._parentMenu && isParentVertical && this._directionality?.value === 'rtl') {\n            event.preventDefault();\n            this.open();\n            this.childMenu?.focusFirstItem('keyboard');\n          }\n        }\n        break;\n\n      case DOWN_ARROW:\n      case UP_ARROW:\n        if (!hasModifierKey(event)) {\n          if (!isParentVertical) {\n            event.preventDefault();\n            this.open();\n            keyCode === DOWN_ARROW\n              ? this.childMenu?.focusFirstItem('keyboard')\n              : this.childMenu?.focusLastItem('keyboard');\n          }\n        }\n        break;\n    }\n  }\n\n  /**\n   * Sets whether the trigger's menu stack has focus.\n   * @param hasFocus Whether the menu stack has focus.\n   */\n  _setHasFocus(hasFocus: boolean) {\n    if (!this._parentMenu) {\n      this.menuStack.setHasFocus(hasFocus);\n    }\n  }\n\n  /**\n   * Subscribe to the mouseenter events and close any sibling menu items if this element is moused\n   * into.\n   */\n  private _subscribeToMouseEnter() {\n    // Closes any sibling menu items and opens the menu associated with this trigger.\n    const toggleMenus = () =>\n      this._ngZone.run(() => {\n        this._closeSiblingTriggers();\n        this.open();\n      });\n\n    this._ngZone.runOutsideAngular(() => {\n      fromEvent(this._elementRef.nativeElement, 'mouseenter')\n        .pipe(\n          filter(() => !this.menuStack.isEmpty() && !this.isOpen()),\n          takeUntil(this.destroyed),\n        )\n        .subscribe(() => {\n          if (this._menuAim) {\n            this._menuAim.toggle(toggleMenus);\n          } else {\n            toggleMenus();\n          }\n        });\n    });\n  }\n\n  /** Close out any sibling menu trigger menus. */\n  private _closeSiblingTriggers() {\n    if (this._parentMenu) {\n      // If nothing was removed from the stack and the last element is not the parent item\n      // that means that the parent menu is a menu bar since we don't put the menu bar on the\n      // stack\n      const isParentMenuBar =\n        !this.menuStack.closeSubMenuOf(this._parentMenu) &&\n        this.menuStack.peek() !== this._parentMenu;\n\n      if (isParentMenuBar) {\n        this.menuStack.closeAll();\n      }\n    } else {\n      this.menuStack.closeAll();\n    }\n  }\n\n  /** Get the configuration object used to create the overlay. */\n  private _getOverlayConfig() {\n    return new OverlayConfig({\n      positionStrategy: this._getOverlayPositionStrategy(),\n      scrollStrategy: this._overlay.scrollStrategies.reposition(),\n      direction: this._directionality,\n    });\n  }\n\n  /** Build the position strategy for the overlay which specifies where to place the menu. */\n  private _getOverlayPositionStrategy(): FlexibleConnectedPositionStrategy {\n    return this._overlay\n      .position()\n      .flexibleConnectedTo(this._elementRef)\n      .withLockedPosition()\n      .withGrowAfterOpen()\n      .withPositions(this._getOverlayPositions());\n  }\n\n  /** Get the preferred positions for the opened menu relative to the menu item. */\n  private _getOverlayPositions(): ConnectedPosition[] {\n    return (\n      this.menuPosition ??\n      (!this._parentMenu || this._parentMenu.orientation === 'horizontal'\n        ? STANDARD_DROPDOWN_BELOW_POSITIONS\n        : STANDARD_DROPDOWN_ADJACENT_POSITIONS)\n    );\n  }\n\n  /**\n   * Subscribe to the MenuStack close events if this is a standalone trigger and close out the menu\n   * this triggers when requested.\n   */\n  private _registerCloseHandler() {\n    if (!this._parentMenu) {\n      this.menuStack.closed.pipe(takeUntil(this.destroyed)).subscribe(({item}) => {\n        if (item === this.childMenu) {\n          this.close();\n        }\n      });\n    }\n  }\n\n  /**\n   * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a\n   * click occurs outside the menus.\n   */\n  private _subscribeToOutsideClicks() {\n    if (this.overlayRef) {\n      this.overlayRef\n        .outsidePointerEvents()\n        .pipe(\n          filter(\n            e =>\n              e.target != this._elementRef.nativeElement &&\n              !this._elementRef.nativeElement.contains(e.target as Element),\n          ),\n          takeUntil(this.stopOutsideClicksListener),\n        )\n        .subscribe(event => {\n          if (!this.isElementInsideMenuStack(event.target as Element)) {\n            this.menuStack.closeAll();\n          } else {\n            this._closeSiblingTriggers();\n          }\n        });\n    }\n  }\n\n  /** Subscribe to the MenuStack hasFocus events. */\n  private _subscribeToMenuStackHasFocus() {\n    if (!this._parentMenu) {\n      this.menuStack.hasFocus.pipe(takeUntil(this.destroyed)).subscribe(hasFocus => {\n        if (!hasFocus) {\n          this.menuStack.closeAll();\n        }\n      });\n    }\n  }\n\n  /** Subscribe to the MenuStack closed events. */\n  private _subscribeToMenuStackClosed() {\n    if (!this._parentMenu) {\n      this.menuStack.closed.subscribe(({focusParentTrigger}) => {\n        if (focusParentTrigger && !this.menuStack.length()) {\n          this._elementRef.nativeElement.focus();\n        }\n      });\n    }\n  }\n}\n"]}

package/esm2020/menu/menu.mjs

@@ -0,0 +1,168 @@
+/**
+ * @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 { Directive, ElementRef, EventEmitter, Inject, NgZone, Optional, Output, Self, } from '@angular/core';
+import { ESCAPE, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, TAB } from '@angular/cdk/keycodes';
+import { Directionality } from '@angular/cdk/bidi';
+import { takeUntil } from 'rxjs/operators';
+import { CdkMenuGroup } from './menu-group';
+import { CDK_MENU } from './menu-interface';
+import { MENU_STACK, MenuStack, PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER, } from './menu-stack';
+import { MENU_AIM } from './menu-aim';
+import { MENU_TRIGGER, CdkMenuTriggerBase } from './menu-trigger-base';
+import { CdkMenuBase } from './menu-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "./menu-stack";
+import * as i3 from "./menu-trigger-base";
+/**
+ * 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 class CdkMenu extends CdkMenuBase {
+    constructor(
+    /** The host element. */
+    elementRef, 
+    /** The Angular zone. */
+    ngZone, 
+    /** The menu stack this menu is part of. */
+    menuStack, 
+    /** The trigger that opened this menu. */
+    _parentTrigger, 
+    /** The menu aim service used by this menu. */
+    menuAim, 
+    /** The directionality of the page. */
+    dir) {
+        super(elementRef, ngZone, menuStack, menuAim, dir);
+        this._parentTrigger = _parentTrigger;
+        /** Event emitted when the menu is closed. */
+        this.closed = new EventEmitter();
+        /** The direction items in the menu flow. */
+        this.orientation = 'vertical';
+        /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+        this.isInline = !this._parentTrigger;
+        this.destroyed.subscribe(this.closed);
+        this._parentTrigger?.registerChildMenu(this);
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+        this._subscribeToMenuStackEmptied();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.closed.complete();
+    }
+    /**
+     * Handle keyboard events for the Menu.
+     * @param event The keyboard event to be handled.
+     */
+    _handleKeyEvent(event) {
+        const keyManager = this.keyManager;
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.onKeydown(event);
+                }
+                break;
+            case ESCAPE:
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.menuStack.close(this, {
+                        focusNextOnEmpty: 2 /* FocusNext.currentItem */,
+                        focusParentTrigger: true,
+                    });
+                }
+                break;
+            case TAB:
+                if (!hasModifierKey(event, 'altKey', 'metaKey', 'ctrlKey')) {
+                    this.menuStack.closeAll({ focusParentTrigger: true });
+                }
+                break;
+            default:
+                keyManager.onKeydown(event);
+        }
+    }
+    /**
+     * Set focus the either the current, previous or next item based on the FocusNext event.
+     * @param focusNext The element to focus.
+     */
+    _toggleMenuFocus(focusNext) {
+        const keyManager = this.keyManager;
+        switch (focusNext) {
+            case 0 /* FocusNext.nextItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setNextItemActive();
+                break;
+            case 1 /* FocusNext.previousItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setPreviousItemActive();
+                break;
+            case 2 /* FocusNext.currentItem */:
+                if (keyManager.activeItem) {
+                    keyManager.setFocusOrigin('keyboard');
+                    keyManager.setActiveItem(keyManager.activeItem);
+                }
+                break;
+        }
+    }
+    /** Subscribe to the MenuStack emptied events. */
+    _subscribeToMenuStackEmptied() {
+        this.menuStack.emptied
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(event => this._toggleMenuFocus(event));
+    }
+}
+CdkMenu.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.16", ngImport: i0, type: CdkMenu, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: MENU_STACK }, { token: MENU_TRIGGER, optional: true }, { token: MENU_AIM, optional: true, self: true }, { token: i1.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenu.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.0-next.16", type: CdkMenu, selector: "[cdkMenu]", outputs: { closed: "closed" }, host: { attributes: { "role": "menu" }, listeners: { "keydown": "_handleKeyEvent($event)" }, properties: { "class.cdk-menu-inline": "isInline" }, classAttribute: "cdk-menu" }, providers: [
+        { provide: CdkMenuGroup, useExisting: CdkMenu },
+        { provide: CDK_MENU, useExisting: CdkMenu },
+        PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER('vertical'),
+    ], exportAs: ["cdkMenu"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.16", ngImport: i0, type: CdkMenu, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenu]',
+                    exportAs: 'cdkMenu',
+                    host: {
+                        'role': 'menu',
+                        'class': 'cdk-menu',
+                        '[class.cdk-menu-inline]': 'isInline',
+                        '(keydown)': '_handleKeyEvent($event)',
+                    },
+                    providers: [
+                        { provide: CdkMenuGroup, useExisting: CdkMenu },
+                        { provide: CDK_MENU, useExisting: CdkMenu },
+                        PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER('vertical'),
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i2.MenuStack, decorators: [{
+                    type: Inject,
+                    args: [MENU_STACK]
+                }] }, { type: i3.CdkMenuTriggerBase, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MENU_TRIGGER]
+                }] }, { type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MENU_AIM]
+                }] }, { type: i1.Directionality, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { closed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../../../../../src/cdk/menu/menu.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  Self,\n} from '@angular/core';\nimport {ESCAPE, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, TAB} from '@angular/cdk/keycodes';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {takeUntil} from 'rxjs/operators';\nimport {CdkMenuGroup} from './menu-group';\nimport {CDK_MENU} from './menu-interface';\nimport {\n  FocusNext,\n  MENU_STACK,\n  MenuStack,\n  PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER,\n} from './menu-stack';\nimport {MENU_AIM, MenuAim} from './menu-aim';\nimport {MENU_TRIGGER, CdkMenuTriggerBase} from './menu-trigger-base';\nimport {CdkMenuBase} from './menu-base';\n\n/**\n * Directive which configures the element as a Menu which should contain child elements marked as\n * CdkMenuItem or CdkMenuGroup. Sets the appropriate role and aria-attributes for a menu and\n * contains accessible keyboard and mouse handling logic.\n *\n * It also acts as a RadioGroup for elements marked with role `menuitemradio`.\n */\n@Directive({\n  selector: '[cdkMenu]',\n  exportAs: 'cdkMenu',\n  host: {\n    'role': 'menu',\n    'class': 'cdk-menu',\n    '[class.cdk-menu-inline]': 'isInline',\n    '(keydown)': '_handleKeyEvent($event)',\n  },\n  providers: [\n    {provide: CdkMenuGroup, useExisting: CdkMenu},\n    {provide: CDK_MENU, useExisting: CdkMenu},\n    PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER('vertical'),\n  ],\n})\nexport class CdkMenu extends CdkMenuBase implements AfterContentInit, OnDestroy {\n  /** Event emitted when the menu is closed. */\n  @Output() readonly closed: EventEmitter<void> = new EventEmitter();\n\n  /** The direction items in the menu flow. */\n  override readonly orientation = 'vertical';\n\n  /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */\n  override readonly isInline = !this._parentTrigger;\n\n  constructor(\n    /** The host element. */\n    elementRef: ElementRef<HTMLElement>,\n    /** The Angular zone. */\n    ngZone: NgZone,\n    /** The menu stack this menu is part of. */\n    @Inject(MENU_STACK) menuStack: MenuStack,\n    /** The trigger that opened this menu. */\n    @Optional() @Inject(MENU_TRIGGER) private _parentTrigger?: CdkMenuTriggerBase,\n    /** The menu aim service used by this menu. */\n    @Self() @Optional() @Inject(MENU_AIM) menuAim?: MenuAim,\n    /** The directionality of the page. */\n    @Optional() dir?: Directionality,\n  ) {\n    super(elementRef, ngZone, menuStack, menuAim, dir);\n    this.destroyed.subscribe(this.closed);\n    this._parentTrigger?.registerChildMenu(this);\n  }\n\n  override ngAfterContentInit() {\n    super.ngAfterContentInit();\n    this._subscribeToMenuStackEmptied();\n  }\n\n  override ngOnDestroy() {\n    super.ngOnDestroy();\n    this.closed.complete();\n  }\n\n  /**\n   * Handle keyboard events for the Menu.\n   * @param event The keyboard event to be handled.\n   */\n  _handleKeyEvent(event: KeyboardEvent) {\n    const keyManager = this.keyManager;\n    switch (event.keyCode) {\n      case LEFT_ARROW:\n      case RIGHT_ARROW:\n        if (!hasModifierKey(event)) {\n          event.preventDefault();\n          keyManager.setFocusOrigin('keyboard');\n          keyManager.onKeydown(event);\n        }\n        break;\n\n      case ESCAPE:\n        if (!hasModifierKey(event)) {\n          event.preventDefault();\n          this.menuStack.close(this, {\n            focusNextOnEmpty: FocusNext.currentItem,\n            focusParentTrigger: true,\n          });\n        }\n        break;\n\n      case TAB:\n        if (!hasModifierKey(event, 'altKey', 'metaKey', 'ctrlKey')) {\n          this.menuStack.closeAll({focusParentTrigger: true});\n        }\n        break;\n\n      default:\n        keyManager.onKeydown(event);\n    }\n  }\n\n  /**\n   * Set focus the either the current, previous or next item based on the FocusNext event.\n   * @param focusNext The element to focus.\n   */\n  private _toggleMenuFocus(focusNext: FocusNext | undefined) {\n    const keyManager = this.keyManager;\n    switch (focusNext) {\n      case FocusNext.nextItem:\n        keyManager.setFocusOrigin('keyboard');\n        keyManager.setNextItemActive();\n        break;\n\n      case FocusNext.previousItem:\n        keyManager.setFocusOrigin('keyboard');\n        keyManager.setPreviousItemActive();\n        break;\n\n      case FocusNext.currentItem:\n        if (keyManager.activeItem) {\n          keyManager.setFocusOrigin('keyboard');\n          keyManager.setActiveItem(keyManager.activeItem);\n        }\n        break;\n    }\n  }\n\n  /** Subscribe to the MenuStack emptied events. */\n  private _subscribeToMenuStackEmptied() {\n    this.menuStack.emptied\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(event => this._toggleMenuFocus(event));\n  }\n}\n"]}

package/esm2020/menu/menu_public_index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudV9wdWJsaWNfaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL21lbnUvbWVudV9wdWJsaWNfaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/menu/pointer-focus-tracker.mjs

@@ -0,0 +1,51 @@
+/**
+ * @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 { defer, fromEvent, Subject } from 'rxjs';
+import { mapTo, mergeAll, mergeMap, startWith, takeUntil } from 'rxjs/operators';
+/**
+ * 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 class PointerFocusTracker {
+    constructor(
+    /** The list of items being tracked. */
+    _items) {
+        this._items = _items;
+        /** Emits when an element is moused into. */
+        this.entered = this._getItemPointerEntries();
+        /** Emits when an element is moused out. */
+        this.exited = this._getItemPointerExits();
+        /** Emits when this is destroyed. */
+        this._destroyed = new Subject();
+        this.entered.subscribe(element => (this.activeElement = element));
+        this.exited.subscribe(() => {
+            this.previousElement = this.activeElement;
+            this.activeElement = undefined;
+        });
+    }
+    /** Stop the managers listeners. */
+    destroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /**
+     * Gets a stream of pointer (mouse) entries into the given items.
+     * This should typically run outside the Angular zone.
+     */
+    _getItemPointerEntries() {
+        return defer(() => this._items.changes.pipe(startWith(this._items), mergeMap((list) => list.map(element => fromEvent(element._elementRef.nativeElement, 'mouseenter').pipe(mapTo(element), takeUntil(this._items.changes)))), mergeAll()));
+    }
+    /**
+     * Gets a stream of pointer (mouse) exits out of the given items.
+     * This should typically run outside the Angular zone.
+     */
+    _getItemPointerExits() {
+        return defer(() => this._items.changes.pipe(startWith(this._items), mergeMap((list) => list.map(element => fromEvent(element._elementRef.nativeElement, 'mouseout').pipe(mapTo(element), takeUntil(this._items.changes)))), mergeAll()));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/menu/public-api.mjs

@@ -0,0 +1,24 @@
+/**
+ * @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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvbWVudS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21lbnUtbW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1iYXInO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51JztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtLWNoZWNrYm94JztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1pdGVtLXJhZGlvJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS10cmlnZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vbWVudS1ncm91cCc7XG5leHBvcnQgKiBmcm9tICcuL21lbnUtaXRlbS1zZWxlY3RhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC1tZW51LXRyaWdnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LXRyaWdnZXItYmFzZSc7XG5leHBvcnQgKiBmcm9tICcuL3BvaW50ZXItZm9jdXMtdHJhY2tlcic7XG5leHBvcnQgKiBmcm9tICcuL21lbnUtc3RhY2snO1xuZXhwb3J0ICogZnJvbSAnLi9tZW51LWludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL21lbnUtYWltJztcbiJdfQ==