@ifsworld/granite-components 4.4.0 → 5.0.1

package/esm2020/lib/menu/menu-base.mjs

@@ -0,0 +1,347 @@
+import { ChangeDetectorRef, ContentChildren, Directive, EventEmitter, Input, Output, QueryList, TemplateRef, ViewChild, } from '@angular/core';
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { hasModifierKey } from '@angular/cdk/keycodes';
+import { BehaviorSubject, combineLatest, merge, Subject, Subscription, } from 'rxjs';
+import { filter, map, startWith, switchMap } from 'rxjs/operators';
+import { throwGraniteMenuInvalidPositionX, throwGraniteMenuInvalidPositionY, } from './menu-errors';
+import { GraniteMenuItemComponent } from './menu-item.component';
+import * as i0 from "@angular/core";
+/** Counter for panel ID generation */
+let menuPanelUid = 0;
+/** Menu panel animation default transform values */
+const transformMenuDefault = {
+    value: 'void',
+    params: {
+        xOffset: 0,
+    },
+};
+/** Base class with all of the menu functionality. */
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class _MenuBaseComponent {
+    constructor(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this.openOnHover = true;
+        /**
+         * Event emitted when the menu is closed
+         */
+        this.closed = new EventEmitter();
+        /**
+         * Used for locating the panel in tests and setting the aria-control attribute
+         * for the menu trigger.
+         */
+        this.panelId = `granite-menu-panel-${menuPanelUid++}`;
+        /** Whether to show back button in touch menu title bar */
+        this.showBackButton = false;
+        /** Whether to show touch menu title bar */
+        this.showTitle = false;
+        /** Whether to add a close button below the menu */
+        this.showCloseButton = false;
+        /** Observable current state of the panel animation. */
+        // eslint-disable-next-line rxjs/no-exposed-subjects
+        this._transformMenu = new BehaviorSubject(transformMenuDefault);
+        /** Emits whenever an animation on the menu completes. */
+        // eslint-disable-next-line rxjs/no-exposed-subjects
+        this._animationDone = new Subject();
+        this._menuEmpty$ = new BehaviorSubject(false);
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this._isMenuEmpty$ = combineLatest([
+            this._menuEmpty$,
+            this._animationDone,
+        ]).pipe(filter(([m, a]) => m && a != null), map(() => true));
+        /** Only the direct descendant menu items. */
+        this._directDescendantItems = new QueryList();
+        /** Subscription to tab events on the menu panel */
+        this._tabSubscription = Subscription.EMPTY;
+        this._xPosition = 'after';
+        this._yPosition = 'below';
+        /**
+         * Current horizontal offset. Used with `pan` and `pan-hidden`
+         * animation states.
+         */
+        this.xOffset = 0;
+    }
+    /** Position of the menu in the X axis. */
+    get xPosition() {
+        return this._xPosition;
+    }
+    set xPosition(value) {
+        if (value !== 'before' && value !== 'after') {
+            throwGraniteMenuInvalidPositionX();
+        }
+        this._xPosition = value;
+    }
+    /** Position of the menu in the Y axis. */
+    get yPosition() {
+        return this._yPosition;
+    }
+    set yPosition(value) {
+        if (value !== 'above' && value !== 'below') {
+            throwGraniteMenuInvalidPositionY();
+        }
+        this._yPosition = value;
+    }
+    /** Current state of the panel animation. */
+    set _panelAnimationState(state) {
+        this._transformMenu.next({
+            value: state,
+            params: { xOffset: this.xOffset },
+        });
+    }
+    ngAfterContentChecked() {
+        this._menuEmpty$.next(this._allItems.length < 1 ? true : false);
+    }
+    ngAfterContentInit() {
+        this._updateDirectDescendants();
+        this._keyManager = new FocusKeyManager(this._directDescendantItems)
+            .withWrap()
+            .skipPredicate((menuItem) => {
+            const hostElement = menuItem._getHostElement();
+            return hostElement instanceof HTMLButtonElement
+                ? hostElement.disabled
+                : hostElement.hasAttribute('graniteTitle');
+        });
+        this._tabSubscription = this._keyManager.tabOut.subscribe(() => {
+            this.closed.emit('tab');
+        });
+        // If a user manually (programatically) focuses a menu item, we need to reflect that focus
+        // change back to the key manager. Note that we don't need to unsubscribe here because _focused
+        // is internal and we know that it gets completed on destroy.
+        this._directDescendantItems.changes
+            .pipe(startWith(this._directDescendantItems), switchMap((items) => merge(...items.map((item) => item._focused))))
+            .subscribe((focusedItem) => this._keyManager.updateActiveItem(focusedItem));
+    }
+    ngOnDestroy() {
+        this._directDescendantItems.destroy();
+        this._tabSubscription.unsubscribe();
+        this.closed.complete();
+    }
+    /**
+     * Stream that combines the `_hovered` observables of all the menu's items
+     * into a single observable. Emits whenever the hovered menu item changes.
+     */
+    _hovered() {
+        // Coerce the `changes` property because Angular types it as `Observable<any>`
+        const itemChanges = this._directDescendantItems.changes;
+        return itemChanges.pipe(startWith(this._directDescendantItems), 
+        // Hovering is not applicable when producing touch output
+        filter(() => {
+            return this._clientOutput?.device !== 'touch';
+        }), switchMap((items) => merge(...items.map((item) => item._hovered))));
+    }
+    /** Handle a keyboard event from the menu, delegating to the appropriate action. */
+    _handleKeydown(event) {
+        const key = event.key;
+        const manager = this._keyManager;
+        switch (key) {
+            case 'Escape':
+                if (!hasModifierKey(event)) {
+                    event.preventDefault();
+                    this.closed.emit('keydown');
+                }
+                break;
+            case 'ArrowLeft':
+                if (this.parentMenu && this.direction === 'ltr') {
+                    this.closed.emit('keydown');
+                }
+                break;
+            case 'ArrowRight':
+                if (this.parentMenu && this.direction === 'rtl') {
+                    this.closed.emit('keydown');
+                }
+                break;
+            case 'Home':
+            case 'End':
+                if (!hasModifierKey(event)) {
+                    key === 'Home'
+                        ? manager.setFirstItemActive()
+                        : manager.setLastItemActive();
+                    event.preventDefault();
+                }
+                break;
+            default:
+                if (key === 'ArrowUp' || key === 'ArrowDown') {
+                    manager.setFocusOrigin('keyboard');
+                }
+                manager.onKeydown(event);
+        }
+    }
+    /**
+     * Focus the first item in the menu.
+     * @param origin Action from which the focus originated. Used to set the correct styling.
+     */
+    focusFirstItem(origin = 'program') {
+        this._keyManager.setFocusOrigin(origin).setFirstItemActive();
+    }
+    /** Updates the `showTitle` property for touch device UI */
+    _updateShowTitle() {
+        this.showTitle = !!this.title || this.showBackButton;
+    }
+    /** Starts the enter animation */
+    _startAnimation() {
+        this._panelAnimationState = 'enter';
+    }
+    /** Resets the panel animation to its initial state. */
+    _resetAnimation() {
+        this._panelAnimationState = 'void';
+    }
+    /**
+     * Starts the 'below' animation, moving a menu down, out of view below the
+     * viewport. Used to close the whole menu, for example when clicking
+     * the backdrop.
+     */
+    _startTouchCloseDownAnimation() {
+        this._panelAnimationState = 'below';
+    }
+    /**
+     * Starts the 'below-with-delay' animation, moving a menu down, out of view below the
+     * viewport. Used to close the whole menu as a response to the user tapping
+     * a menu item. There is a short delay before the animation starts, to that
+     * the user gets a visual feedback on what item was selected.
+     */
+    _startTouchCloseDownAnimationWithDelay() {
+        this._panelAnimationState = 'below-with-delay';
+    }
+    /**
+     * Starts the 'void' animation, moving a (sub) menu out of view to the side
+     * of the viewport. Used when going "back" from a sub menu.
+     */
+    _startTouchCloseSideAnimation() {
+        this._resetAnimation();
+    }
+    /**
+     * Starts the enter-from-below animation, moving a (root) menu into view,
+     * Animates upwards from a starting position below the viewport.
+     */
+    _startTouchRootEnterAnimation() {
+        this._panelAnimationState = 'enter-from-below';
+        this.xOffset = 0;
+    }
+    /** Starts the enter animation, moving a (sub) menu into view. */
+    _startTouchSubmenuEnterAnimation() {
+        this._panelAnimationState = 'enter';
+        this.xOffset = 0;
+    }
+    /**
+     * Starts the pan animation, to position a submenu in a response
+     * to user dragging sideways (panning).
+     */
+    _startTouchPanAnimation(xOffset) {
+        this._panelAnimationState = 'pan';
+        this.xOffset = xOffset;
+    }
+    /**
+     * Starts the pan-hidden animation, to position a parent menu next to an
+     * active submenu that the user is dragging sideways (panning).
+     */
+    _startTouchHidePanAnimation(xOffset) {
+        this._panelAnimationState = 'pan-hidden';
+        this.xOffset = xOffset;
+    }
+    /**
+     * Starts the hide animation, to make a parent menu slide out to leave
+     * space for a submenu.
+     */
+    _startTouchHideAnimation() {
+        this._panelAnimationState = 'hide';
+        this.xOffset = 0;
+    }
+    /** Callback that is invoked when the panel animation completes. */
+    _onAnimationDone(event) {
+        this._animationDone.next(event);
+        this._isAnimating = false;
+    }
+    _onAnimationStart(event) {
+        this._isAnimating = true;
+        // Scroll the content element to the top as soon as the animation starts. This is necessary,
+        // because we move focus to the first item while it's still being animated, which can throw
+        // the browser off when it determines the scroll position. Alternatively we can move focus
+        // when the animation is done, however moving focus asynchronously will interrupt screen
+        // readers which are in the process of reading out the menu already. We take the `element`
+        // from the `event` since we can't use a `ViewChild` to access the pane.
+        if ((event.toState === 'enter' || event.toState === 'enter-from-below') &&
+            this._keyManager.activeItemIndex === 0) {
+            event.element.scrollTop = 0;
+        }
+    }
+    /**
+     * Handle click on the menu by emitting on the `closed` emitter
+     * with a `click` reason
+     */
+    _handleClick() {
+        this.closed.emit('click');
+    }
+    /**
+     * Handle click on the close button by emitting on the `closed` emitter
+     * without any particular reason
+     */
+    _handleCloseClick() {
+        this.closed.emit();
+    }
+    /**
+     * Handle click on the back icon by emitting on the `clicked` emitter
+     */
+    _handleBackClick(e) {
+        if (this.showBackButton) {
+            // Close submenu keydown-style: close only this menu and leave parents open
+            this.closed.emit('keydown');
+        }
+        e.stopPropagation();
+    }
+    /**
+     * Update client device information for the menu and its menu items.
+     */
+    _setDevice(clientInput, clientOutput) {
+        this._clientInput = clientInput;
+        this._clientOutput = clientOutput;
+        this._directDescendantItems.forEach((item) => {
+            item._clientInput = clientInput;
+            item._clientOutput = clientOutput;
+        });
+        this._changeDetectorRef.markForCheck();
+    }
+    /**
+     * Resets the active item in the menu. This is used when the menu is opened, allowing
+     * the user to start from the first option when pressing the down arrow.
+     */
+    resetActiveItem() {
+        this._keyManager.setActiveItem(-1);
+    }
+    /**
+     * Sets up a stream that will keep track of any newly-added menu items and will update the list
+     * of direct descendants. We collect the descendants this way, because `_allItems` can include
+     * items that are part of child menus, and using a custom way of registering items is unreliable
+     * when it comes to maintaining the item order.
+     */
+    _updateDirectDescendants() {
+        this._allItems.changes
+            .pipe(startWith(this._allItems))
+            .subscribe((items) => {
+            this._directDescendantItems.reset(items.filter((item) => item._parentMenu === this));
+            this._directDescendantItems.notifyOnChanges();
+        });
+    }
+}
+_MenuBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: _MenuBaseComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+_MenuBaseComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: _MenuBaseComponent, inputs: { xPosition: "xPosition", yPosition: "yPosition", title: "title", closeLabel: "closeLabel", openOnHover: "openOnHover" }, outputs: { closed: "closed" }, queries: [{ propertyName: "_allItems", predicate: GraniteMenuItemComponent, descendants: true }], viewQueries: [{ propertyName: "templateRef", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: _MenuBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { xPosition: [{
+                type: Input
+            }], yPosition: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], closeLabel: [{
+                type: Input
+            }], openOnHover: [{
+                type: Input
+            }], templateRef: [{
+                type: ViewChild,
+                args: [TemplateRef]
+            }], _allItems: [{
+                type: ContentChildren,
+                args: [GraniteMenuItemComponent, { descendants: true }]
+            }], closed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-base.js","sourceRoot":"","sources":["../../../../../../libs/granite-components/src/lib/menu/menu-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentChecked,\n  AfterContentInit,\n  ChangeDetectorRef,\n  ContentChildren,\n  Directive,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  TemplateRef,\n  ViewChild,\n} from '@angular/core';\nimport { FocusKeyManager, FocusOrigin } from '@angular/cdk/a11y';\nimport { Direction } from '@angular/cdk/bidi';\nimport { hasModifierKey } from '@angular/cdk/keycodes';\nimport { AnimationEvent } from '@angular/animations';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  merge,\n  Observable,\n  Subject,\n  Subscription,\n} from 'rxjs';\nimport { filter, map, startWith, switchMap } from 'rxjs/operators';\n\nimport {\n  ClientInputInterface,\n  ClientOutputInterface,\n} from '../core/client-environment';\nimport {\n  throwGraniteMenuInvalidPositionX,\n  throwGraniteMenuInvalidPositionY,\n} from './menu-errors';\nimport { GraniteMenuItemComponent } from './menu-item.component';\nimport { ClosedEventType, GraniteMenuPanelInterface } from './menu-panel';\nimport { MenuPositionX, MenuPositionY } from './menu-positions';\n\n/** Counter for panel ID generation */\nlet menuPanelUid = 0;\n\n/** Menu panel animation states */\ntype TransformMenuStates =\n  // Touch device\n  | 'void'\n  | 'enter'\n  | 'enter-from-below'\n  | 'below-with-delay'\n  | 'below'\n  | 'pan'\n  | 'hide'\n  | 'pan-hidden';\n\n/**\n * Menu panel animation transform/state object. Has to be an object as we supply\n * the `xOffset` parameter and not just the state name.\n */\ntype TransformMenu = {\n  /** Current animation state name */\n  value: TransformMenuStates;\n  params: {\n    /** How far the menu has been panned/swiped by the user */\n    xOffset: number;\n  };\n};\n\n/** Menu panel animation default transform values */\nconst transformMenuDefault: TransformMenu = {\n  value: 'void',\n  params: {\n    xOffset: 0,\n  },\n};\n\n/** Base class with all of the menu functionality. */\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport class _MenuBaseComponent\n  implements\n    AfterContentInit,\n    OnDestroy,\n    AfterContentChecked,\n    GraniteMenuPanelInterface\n{\n  /** Position of the menu in the X axis. */\n  @Input()\n  get xPosition(): MenuPositionX {\n    return this._xPosition;\n  }\n  set xPosition(value: MenuPositionX) {\n    if (value !== 'before' && value !== 'after') {\n      throwGraniteMenuInvalidPositionX();\n    }\n    this._xPosition = value;\n  }\n\n  /** Position of the menu in the Y axis. */\n  @Input()\n  get yPosition(): MenuPositionY {\n    return this._yPosition;\n  }\n  set yPosition(value: MenuPositionY) {\n    if (value !== 'above' && value !== 'below') {\n      throwGraniteMenuInvalidPositionY();\n    }\n    this._yPosition = value;\n  }\n\n  /** Optional touch menu panel title */\n  @Input()\n  title: string;\n\n  /**\n   * Touch menu close button label. If not set, any label set by parent will\n   * be used.\n   */\n  @Input()\n  closeLabel: string;\n\n  @Input()\n  openOnHover: boolean = true;\n\n  @ViewChild(TemplateRef) templateRef: TemplateRef<any>;\n\n  /** All items inside the menu. Includes items nested inside another menu. */\n  @ContentChildren(GraniteMenuItemComponent, { descendants: true })\n  _allItems: QueryList<GraniteMenuItemComponent>;\n\n  /**\n   * Event emitted when the menu is closed\n   */\n  @Output() readonly closed: EventEmitter<ClosedEventType> = new EventEmitter();\n\n  /**\n   * Used for locating the panel in tests and setting the aria-control attribute\n   * for the menu trigger.\n   */\n  readonly panelId = `granite-menu-panel-${menuPanelUid++}`;\n\n  /** Parent menu of the current menu panel. */\n  parentMenu: GraniteMenuPanelInterface | undefined;\n\n  /** Layout direction of the menu. */\n  direction: Direction;\n\n  /** Whether to show back button in touch menu title bar */\n  showBackButton: boolean = false;\n\n  /** Whether to show touch menu title bar */\n  showTitle: boolean = false;\n\n  /** Whether to add a close button below the menu */\n  showCloseButton: boolean = false;\n\n  /** Observable current state of the panel animation. */\n  // eslint-disable-next-line rxjs/no-exposed-subjects\n  _transformMenu: BehaviorSubject<TransformMenu> = new BehaviorSubject(\n    transformMenuDefault\n  );\n\n  /** Emits whenever an animation on the menu completes. */\n  // eslint-disable-next-line rxjs/no-exposed-subjects\n  _animationDone = new Subject<AnimationEvent>();\n\n  /** Whether the menu is animating. */\n  _isAnimating: boolean;\n\n  /** Whether the menu is about to be destroyed. */\n  _isClosing: boolean;\n\n  /** Client input device information */\n  _clientInput: ClientInputInterface;\n\n  /** Client output device information */\n  _clientOutput: ClientOutputInterface;\n\n  private _menuEmpty$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  _isMenuEmpty$: Observable<boolean> = combineLatest([\n    this._menuEmpty$,\n    this._animationDone,\n  ]).pipe(\n    filter(([m, a]) => m && a != null),\n    map(() => true)\n  );\n\n  /** Only the direct descendant menu items. */\n  private _directDescendantItems = new QueryList<GraniteMenuItemComponent>();\n\n  private _keyManager: FocusKeyManager<GraniteMenuItemComponent>;\n\n  /** Subscription to tab events on the menu panel */\n  private _tabSubscription = Subscription.EMPTY;\n\n  private _xPosition: MenuPositionX = 'after';\n  private _yPosition: MenuPositionY = 'below';\n\n  /** Current state of the panel animation. */\n  set _panelAnimationState(state: TransformMenuStates) {\n    this._transformMenu.next({\n      value: state,\n      params: { xOffset: this.xOffset },\n    });\n  }\n\n  /**\n   * Current horizontal offset. Used with `pan` and `pan-hidden`\n   * animation states.\n   */\n  private xOffset: number = 0;\n\n  constructor(private _changeDetectorRef: ChangeDetectorRef) {}\n\n  ngAfterContentChecked(): void {\n    this._menuEmpty$.next(this._allItems.length < 1 ? true : false);\n  }\n\n  ngAfterContentInit(): void {\n    this._updateDirectDescendants();\n    this._keyManager = new FocusKeyManager(this._directDescendantItems)\n      .withWrap()\n      .skipPredicate((menuItem) => {\n        const hostElement: HTMLElement = menuItem._getHostElement();\n        return hostElement instanceof HTMLButtonElement\n          ? hostElement.disabled\n          : hostElement.hasAttribute('graniteTitle');\n      });\n    this._tabSubscription = this._keyManager.tabOut.subscribe(() => {\n      this.closed.emit('tab');\n    });\n\n    // If a user manually (programatically) focuses a menu item, we need to reflect that focus\n    // change back to the key manager. Note that we don't need to unsubscribe here because _focused\n    // is internal and we know that it gets completed on destroy.\n    this._directDescendantItems.changes\n      .pipe(\n        startWith(this._directDescendantItems),\n        switchMap((items) =>\n          merge<GraniteMenuItemComponent>(\n            ...items.map((item: GraniteMenuItemComponent) => item._focused)\n          )\n        )\n      )\n      .subscribe((focusedItem) =>\n        this._keyManager.updateActiveItem(focusedItem)\n      );\n  }\n\n  ngOnDestroy(): void {\n    this._directDescendantItems.destroy();\n    this._tabSubscription.unsubscribe();\n    this.closed.complete();\n  }\n\n  /**\n   * Stream that combines the `_hovered` observables of all the menu's items\n   * into a single observable. Emits whenever the hovered menu item changes.\n   */\n  _hovered(): Observable<GraniteMenuItemComponent> {\n    // Coerce the `changes` property because Angular types it as `Observable<any>`\n    const itemChanges = this._directDescendantItems.changes as Observable<\n      QueryList<GraniteMenuItemComponent>\n    >;\n\n    return itemChanges.pipe(\n      startWith(this._directDescendantItems),\n      // Hovering is not applicable when producing touch output\n      filter(() => {\n        return this._clientOutput?.device !== 'touch';\n      }),\n      switchMap((items) =>\n        merge(...items.map((item: GraniteMenuItemComponent) => item._hovered))\n      )\n    ) as Observable<GraniteMenuItemComponent>;\n  }\n\n  /** Handle a keyboard event from the menu, delegating to the appropriate action. */\n  _handleKeydown(event: KeyboardEvent): void {\n    const key = event.key;\n    const manager = this._keyManager;\n\n    switch (key) {\n      case 'Escape':\n        if (!hasModifierKey(event)) {\n          event.preventDefault();\n          this.closed.emit('keydown');\n        }\n        break;\n      case 'ArrowLeft':\n        if (this.parentMenu && this.direction === 'ltr') {\n          this.closed.emit('keydown');\n        }\n        break;\n      case 'ArrowRight':\n        if (this.parentMenu && this.direction === 'rtl') {\n          this.closed.emit('keydown');\n        }\n        break;\n      case 'Home':\n      case 'End':\n        if (!hasModifierKey(event)) {\n          key === 'Home'\n            ? manager.setFirstItemActive()\n            : manager.setLastItemActive();\n          event.preventDefault();\n        }\n        break;\n      default:\n        if (key === 'ArrowUp' || key === 'ArrowDown') {\n          manager.setFocusOrigin('keyboard');\n        }\n\n        manager.onKeydown(event);\n    }\n  }\n\n  /**\n   * Focus the first item in the menu.\n   * @param origin Action from which the focus originated. Used to set the correct styling.\n   */\n  focusFirstItem(origin: FocusOrigin = 'program'): void {\n    this._keyManager.setFocusOrigin(origin).setFirstItemActive();\n  }\n\n  /** Updates the `showTitle` property for touch device UI */\n  _updateShowTitle(): void {\n    this.showTitle = !!this.title || this.showBackButton;\n  }\n\n  /** Starts the enter animation */\n  _startAnimation(): void {\n    this._panelAnimationState = 'enter';\n  }\n\n  /** Resets the panel animation to its initial state. */\n  _resetAnimation(): void {\n    this._panelAnimationState = 'void';\n  }\n\n  /**\n   * Starts the 'below' animation, moving a menu down, out of view below the\n   * viewport. Used to close the whole menu, for example when clicking\n   * the backdrop.\n   */\n  _startTouchCloseDownAnimation(): void {\n    this._panelAnimationState = 'below';\n  }\n\n  /**\n   * Starts the 'below-with-delay' animation, moving a menu down, out of view below the\n   * viewport. Used to close the whole menu as a response to the user tapping\n   * a menu item. There is a short delay before the animation starts, to that\n   * the user gets a visual feedback on what item was selected.\n   */\n  _startTouchCloseDownAnimationWithDelay(): void {\n    this._panelAnimationState = 'below-with-delay';\n  }\n\n  /**\n   * Starts the 'void' animation, moving a (sub) menu out of view to the side\n   * of the viewport. Used when going \"back\" from a sub menu.\n   */\n  _startTouchCloseSideAnimation(): void {\n    this._resetAnimation();\n  }\n\n  /**\n   * Starts the enter-from-below animation, moving a (root) menu into view,\n   * Animates upwards from a starting position below the viewport.\n   */\n  _startTouchRootEnterAnimation(): void {\n    this._panelAnimationState = 'enter-from-below';\n    this.xOffset = 0;\n  }\n\n  /** Starts the enter animation, moving a (sub) menu into view. */\n  _startTouchSubmenuEnterAnimation(): void {\n    this._panelAnimationState = 'enter';\n    this.xOffset = 0;\n  }\n\n  /**\n   * Starts the pan animation, to position a submenu in a response\n   * to user dragging sideways (panning).\n   */\n  _startTouchPanAnimation(xOffset: number): void {\n    this._panelAnimationState = 'pan';\n    this.xOffset = xOffset;\n  }\n\n  /**\n   * Starts the pan-hidden animation, to position a parent menu next to an\n   * active submenu that the user is dragging sideways (panning).\n   */\n  _startTouchHidePanAnimation(xOffset: number): void {\n    this._panelAnimationState = 'pan-hidden';\n    this.xOffset = xOffset;\n  }\n\n  /**\n   * Starts the hide animation, to make a parent menu slide out to leave\n   * space for a submenu.\n   */\n  _startTouchHideAnimation(): void {\n    this._panelAnimationState = 'hide';\n    this.xOffset = 0;\n  }\n\n  /** Callback that is invoked when the panel animation completes. */\n  _onAnimationDone(event: AnimationEvent): void {\n    this._animationDone.next(event);\n    this._isAnimating = false;\n  }\n\n  _onAnimationStart(event: AnimationEvent): void {\n    this._isAnimating = true;\n\n    // Scroll the content element to the top as soon as the animation starts. This is necessary,\n    // because we move focus to the first item while it's still being animated, which can throw\n    // the browser off when it determines the scroll position. Alternatively we can move focus\n    // when the animation is done, however moving focus asynchronously will interrupt screen\n    // readers which are in the process of reading out the menu already. We take the `element`\n    // from the `event` since we can't use a `ViewChild` to access the pane.\n    if (\n      (event.toState === 'enter' || event.toState === 'enter-from-below') &&\n      this._keyManager.activeItemIndex === 0\n    ) {\n      event.element.scrollTop = 0;\n    }\n  }\n\n  /**\n   * Handle click on the menu by emitting on the `closed` emitter\n   * with a `click` reason\n   */\n  _handleClick(): void {\n    this.closed.emit('click');\n  }\n\n  /**\n   * Handle click on the close button by emitting on the `closed` emitter\n   * without any particular reason\n   */\n  _handleCloseClick(): void {\n    this.closed.emit();\n  }\n\n  /**\n   * Handle click on the back icon by emitting on the `clicked` emitter\n   */\n  _handleBackClick(e: MouseEvent): void {\n    if (this.showBackButton) {\n      // Close submenu keydown-style: close only this menu and leave parents open\n      this.closed.emit('keydown');\n    }\n    e.stopPropagation();\n  }\n\n  /**\n   * Update client device information for the menu and its menu items.\n   */\n  _setDevice(\n    clientInput: ClientInputInterface,\n    clientOutput: ClientOutputInterface\n  ): void {\n    this._clientInput = clientInput;\n    this._clientOutput = clientOutput;\n\n    this._directDescendantItems.forEach((item) => {\n      item._clientInput = clientInput;\n      item._clientOutput = clientOutput;\n    });\n\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /**\n   * Resets the active item in the menu. This is used when the menu is opened, allowing\n   * the user to start from the first option when pressing the down arrow.\n   */\n  resetActiveItem(): void {\n    this._keyManager.setActiveItem(-1);\n  }\n\n  /**\n   * Sets up a stream that will keep track of any newly-added menu items and will update the list\n   * of direct descendants. We collect the descendants this way, because `_allItems` can include\n   * items that are part of child menus, and using a custom way of registering items is unreliable\n   * when it comes to maintaining the item order.\n   */\n  private _updateDirectDescendants() {\n    this._allItems.changes\n      .pipe(startWith(this._allItems))\n      .subscribe((items: QueryList<GraniteMenuItemComponent>) => {\n        this._directDescendantItems.reset(\n          items.filter((item) => item._parentMenu === this)\n        );\n        this._directDescendantItems.notifyOnChanges();\n      });\n  }\n}\n"]}

package/esm2020/lib/menu/menu-desktop-animations.mjs

@@ -0,0 +1,23 @@
+import { trigger, state, style, animate, group, query, transition, } from '@angular/animations';
+import { getEaseLinear, getEaseOutSteep } from '../core/animation';
+const easeOut120 = getEaseOutSteep(120);
+/**
+ * Animations used by the `granite-menu` component, showing the desktop interface.
+ * @docs-private
+ */
+export const graniteMenuDesktopAnimations = {
+    transformMenuDesktop: trigger('transformMenuDesktop', [
+        state('void', style({
+            opacity: 0,
+            transform: 'scale(0.9)',
+        })),
+        transition('void => enter', group([
+            query('.granite-menu-content', animate(getEaseLinear(100), style({
+                opacity: 1,
+            }))),
+            animate(easeOut120, style({ transform: 'scale(1)' })),
+        ])),
+        transition('* => void', animate(getEaseLinear(100, 25), style({ opacity: 0 }))),
+    ]),
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/menu/menu-errors.mjs

@@ -0,0 +1,37 @@
+/**
+ * @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 for the case when menu trigger doesn't have a valid granite-menu instance
+ * @docs-private
+ */
+export function throwGraniteMenuMissingError() {
+    throw Error(`graniteMenuTriggerFor: must pass in an granite-menu instance.
+
+    Example:
+      <granite-menu #menu="graniteMenu"></granite-menu>
+      <button [graniteMenuTriggerFor]="menu"></button>`);
+}
+/**
+ * Throws an exception for the case when menu's x-position value isn't valid.
+ * In other words, it doesn't match 'before' or 'after'.
+ * @docs-private
+ */
+export function throwGraniteMenuInvalidPositionX() {
+    throw Error(`xPosition value must be either 'before' or after'.
+      Example: <granite-menu xPosition="before" #menu="graniteMenu"></granite-menu>`);
+}
+/**
+ * Throws an exception for the case when menu's y-position value isn't valid.
+ * In other words, it doesn't match 'above' or 'below'.
+ * @docs-private
+ */
+export function throwGraniteMenuInvalidPositionY() {
+    throw Error(`yPosition value must be either 'above' or below'.
+      Example: <granite-menu yPosition="above" #menu="graniteMenu"></granite-menu>`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/menu/menu-item.component.mjs

@@ -0,0 +1,91 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Component, ElementRef, Inject, Input, Optional, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { GRANITE_MENU_PANEL } from './menu-panel';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+import * as i2 from "../icon/icon.component";
+import * as i3 from "@angular/common";
+export class GraniteMenuItemComponent {
+    constructor(_elementRef, _focusMonitor, _parentMenu) {
+        this._elementRef = _elementRef;
+        this._focusMonitor = _focusMonitor;
+        this._parentMenu = _parentMenu;
+        /** ARIA role for the menu item. */
+        this.role = 'menuitem';
+        /** Stream that emits when the menu item is hovered. */
+        // eslint-disable-next-line rxjs/no-exposed-subjects
+        this._hovered = new Subject();
+        /** Stream that emits when the menu item is focused. */
+        // eslint-disable-next-line rxjs/no-exposed-subjects
+        this._focused = new Subject();
+        /** Whether the menu item acts as a trigger for a sub-menu (used for styling) */
+        this._triggersSubmenu = false;
+        /**
+         * Whether the menu item is highlighted, e.g. in the "breadcrumb" parent chain
+         * of sub menu trigger items
+         */
+        this._highlighted = false;
+        // Start monitoring the element so it gets the appropriate focused classes. We want
+        // to show the focus style for menu items only when the focus was not caused by a
+        // mouse or touch interaction.
+        _focusMonitor.monitor(this._elementRef, false);
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        this._hovered.complete();
+        this._focused.complete();
+    }
+    /** Focuses the menu item. */
+    focus(origin = 'program', options) {
+        this._focusMonitor.focusVia(this._getHostElement(), origin, options);
+        this._focused.next(this);
+    }
+    /** Returns the host DOM element. */
+    _getHostElement() {
+        return this._elementRef.nativeElement;
+    }
+}
+GraniteMenuItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GraniteMenuItemComponent, deps: [{ token: i0.ElementRef }, { token: i1.FocusMonitor }, { token: GRANITE_MENU_PANEL, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+GraniteMenuItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: GraniteMenuItemComponent, selector: "[graniteMenuItem]", inputs: { role: "role" }, host: { listeners: { "mouseenter": "_hovered.next(this)" }, properties: { "attr.role": "role", "class.granite-menu-item": "true", "class.granite-menu-item-highlighted": "_highlighted", "class.granite-menu-item-submenu-trigger": "_triggersSubmenu", "class.granite-device-output-touch": "_clientOutput?.device === \"touch\"" } }, exportAs: ["graniteMenuItem"], ngImport: i0, template: `<ng-content></ng-content>
+    <ng-container *ngIf="_triggersSubmenu">
+      <granite-icon
+        class="caret-left"
+        [fontIcon]="'icon-caret-left'"
+      ></granite-icon>
+      <granite-icon
+        class="caret-right"
+        [fontIcon]="'icon-caret-right'"
+      ></granite-icon>
+    </ng-container>`, isInline: true, styles: [":host{display:block;position:relative;line-height:2rem;padding:0 var(--granite-spacing-s);width:100%;max-width:100%;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;text-align:start;text-decoration:none;background-color:var(--granite-color-background-variant);color:var(--granite-color-text);font-size:var(--granite-font-size-body-small);font-family:inherit}@media (hover: hover) and (pointer: fine){:host:hover:not(.granite-title):not([disabled]){background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}}@media (hover: none) and (pointer: coarse){:host:active:not(.granite-title):not([disabled]){background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}}:host.granite-title{-webkit-user-select:none;user-select:none;display:flex;align-items:center;line-height:1.5rem;width:100%;outline:none;border:none;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;text-decoration:none;color:var(--granite-color-text);font-size:var(--granite-font-size-micro);font-weight:var(--granite-font-weight-bold);cursor:default}:host.cdk-mouse-focused,:host.cdk-program-focused,:host.cdk-keyboard-focused,:host.granite-menu-item-highlighted{background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}:host granite-icon{position:absolute;font-size:var(--granite-font-size-body-small);color:inherit;top:50%;transform:translateY(-50%)}:host.granite-menu-item-submenu-trigger{padding-inline-end:var(--granite-spacing-l)}html[dir=ltr] :host.granite-menu-item-submenu-trigger granite-icon{right:var(--granite-spacing-xs)}:host-context([dir=ltr]) :host.granite-menu-item-submenu-trigger granite-icon{right:var(--granite-spacing-xs)}html[dir=rtl] :host.granite-menu-item-submenu-trigger granite-icon{left:var(--granite-spacing-xs)}:host-context([dir=rtl]) :host.granite-menu-item-submenu-trigger granite-icon{left:var(--granite-spacing-xs)}[dir=rtl] :host.granite-menu-item-submenu-trigger granite-icon.caret-right{display:none}[dir=ltr] :host.granite-menu-item-submenu-trigger granite-icon.caret-left{display:none}:host.granite-divider-top{border-top:.0625rem solid var(--granite-color-border-soft)}:host.granite-divider-bottom{border-bottom:.0625rem solid var(--granite-color-border-soft)}:host.granite-device-output-touch{line-height:3rem;font-size:var(--granite-font-size-body-small);text-align:center;padding:0 var(--granite-spacing-l)}:host.granite-device-output-touch.granite-title{padding:0;justify-content:center;line-height:1.5rem;font-size:var(--granite-font-size-micro)}:host.granite-device-output-touch.granite-menu-item-back-trigger,:host.granite-device-output-touch.granite-menu-item-submenu-trigger{padding:0 var(--granite-spacing-l)}:host.granite-device-output-touch.granite-menu-item-title{line-height:3rem;height:3rem;font-size:var(--granite-font-size-micro);color:var(--granite-color-text-weak)}@media (hover: none) and (pointer: coarse){:host.granite-device-output-touch.granite-menu-item-title:active{background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}}html[dir=ltr] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{left:var(--granite-spacing-xs)}:host-context([dir=ltr]) :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{left:var(--granite-spacing-xs)}html[dir=rtl] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{right:var(--granite-spacing-xs)}:host-context([dir=rtl]) :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{right:var(--granite-spacing-xs)}[dir=rtl] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon.caret-left{display:none}[dir=ltr] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon.caret-right{display:none}:host:disabled:not(.granite-menu-item-title){opacity:.4;cursor:default}\n"], components: [{ type: i2.GraniteIconComponent, selector: "granite-icon", inputs: ["fontIcon"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GraniteMenuItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[graniteMenuItem]', template: `<ng-content></ng-content>
+    <ng-container *ngIf="_triggersSubmenu">
+      <granite-icon
+        class="caret-left"
+        [fontIcon]="'icon-caret-left'"
+      ></granite-icon>
+      <granite-icon
+        class="caret-right"
+        [fontIcon]="'icon-caret-right'"
+      ></granite-icon>
+    </ng-container>`, exportAs: 'graniteMenuItem', host: {
+                        '[attr.role]': 'role',
+                        '[class.granite-menu-item]': 'true',
+                        '[class.granite-menu-item-highlighted]': '_highlighted',
+                        '[class.granite-menu-item-submenu-trigger]': '_triggersSubmenu',
+                        //#region --- Touch device customizations ---
+                        '[class.granite-device-output-touch]': '_clientOutput?.device === "touch"',
+                        //#endregion --- Touch device customizations ---
+                        '(mouseenter)': '_hovered.next(this)',
+                    }, styles: [":host{display:block;position:relative;line-height:2rem;padding:0 var(--granite-spacing-s);width:100%;max-width:100%;-webkit-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;text-align:start;text-decoration:none;background-color:var(--granite-color-background-variant);color:var(--granite-color-text);font-size:var(--granite-font-size-body-small);font-family:inherit}@media (hover: hover) and (pointer: fine){:host:hover:not(.granite-title):not([disabled]){background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}}@media (hover: none) and (pointer: coarse){:host:active:not(.granite-title):not([disabled]){background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}}:host.granite-title{-webkit-user-select:none;user-select:none;display:flex;align-items:center;line-height:1.5rem;width:100%;outline:none;border:none;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;text-decoration:none;color:var(--granite-color-text);font-size:var(--granite-font-size-micro);font-weight:var(--granite-font-weight-bold);cursor:default}:host.cdk-mouse-focused,:host.cdk-program-focused,:host.cdk-keyboard-focused,:host.granite-menu-item-highlighted{background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}:host granite-icon{position:absolute;font-size:var(--granite-font-size-body-small);color:inherit;top:50%;transform:translateY(-50%)}:host.granite-menu-item-submenu-trigger{padding-inline-end:var(--granite-spacing-l)}html[dir=ltr] :host.granite-menu-item-submenu-trigger granite-icon{right:var(--granite-spacing-xs)}:host-context([dir=ltr]) :host.granite-menu-item-submenu-trigger granite-icon{right:var(--granite-spacing-xs)}html[dir=rtl] :host.granite-menu-item-submenu-trigger granite-icon{left:var(--granite-spacing-xs)}:host-context([dir=rtl]) :host.granite-menu-item-submenu-trigger granite-icon{left:var(--granite-spacing-xs)}[dir=rtl] :host.granite-menu-item-submenu-trigger granite-icon.caret-right{display:none}[dir=ltr] :host.granite-menu-item-submenu-trigger granite-icon.caret-left{display:none}:host.granite-divider-top{border-top:.0625rem solid var(--granite-color-border-soft)}:host.granite-divider-bottom{border-bottom:.0625rem solid var(--granite-color-border-soft)}:host.granite-device-output-touch{line-height:3rem;font-size:var(--granite-font-size-body-small);text-align:center;padding:0 var(--granite-spacing-l)}:host.granite-device-output-touch.granite-title{padding:0;justify-content:center;line-height:1.5rem;font-size:var(--granite-font-size-micro)}:host.granite-device-output-touch.granite-menu-item-back-trigger,:host.granite-device-output-touch.granite-menu-item-submenu-trigger{padding:0 var(--granite-spacing-l)}:host.granite-device-output-touch.granite-menu-item-title{line-height:3rem;height:3rem;font-size:var(--granite-font-size-micro);color:var(--granite-color-text-weak)}@media (hover: none) and (pointer: coarse){:host.granite-device-output-touch.granite-menu-item-title:active{background:var(--granite-color-background-active-hover);color:var(--granite-color-text-on-active)}}html[dir=ltr] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{left:var(--granite-spacing-xs)}:host-context([dir=ltr]) :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{left:var(--granite-spacing-xs)}html[dir=rtl] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{right:var(--granite-spacing-xs)}:host-context([dir=rtl]) :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon{right:var(--granite-spacing-xs)}[dir=rtl] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon.caret-left{display:none}[dir=ltr] :host.granite-device-output-touch.granite-menu-item-back-trigger granite-icon.caret-right{display:none}:host:disabled:not(.granite-menu-item-title){opacity:.4;cursor:default}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusMonitor }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GRANITE_MENU_PANEL]
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { role: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/menu/menu-panel.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token used to provide the parent menu to menu-specific components.
+ * @docs-private
+ */
+export const GRANITE_MENU_PANEL = new InjectionToken('GRANITE_MENU_PANEL');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wYW5lbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZ3Jhbml0ZS1jb21wb25lbnRzL3NyYy9saWIvbWVudS9tZW51LXBhbmVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBZ0IsY0FBYyxFQUFlLE1BQU0sZUFBZSxDQUFDO0FBRzFFOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLElBQUksY0FBYyxDQUNsRCxvQkFBb0IsQ0FDckIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvY3VzT3JpZ2luIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknO1xuaW1wb3J0IHsgRGlyZWN0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2JpZGknO1xuaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3Rpb25Ub2tlbiwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1lbnVQb3NpdGlvblgsIE1lbnVQb3NpdGlvblkgfSBmcm9tICcuL21lbnUtcG9zaXRpb25zJztcblxuLyoqXG4gKiBJbmplY3Rpb24gdG9rZW4gdXNlZCB0byBwcm92aWRlIHRoZSBwYXJlbnQgbWVudSB0byBtZW51LXNwZWNpZmljIGNvbXBvbmVudHMuXG4gKiBAZG9jcy1wcml2YXRlXG4gKi9cbmV4cG9ydCBjb25zdCBHUkFOSVRFX01FTlVfUEFORUwgPSBuZXcgSW5qZWN0aW9uVG9rZW48R3Jhbml0ZU1lbnVQYW5lbEludGVyZmFjZT4oXG4gICdHUkFOSVRFX01FTlVfUEFORUwnXG4pO1xuXG5leHBvcnQgdHlwZSBDbG9zZWRFdmVudFR5cGUgPSB2b2lkIHwgJ2NsaWNrJyB8ICdrZXlkb3duJyB8ICd0YWInO1xuXG5leHBvcnQgaW50ZXJmYWNlIEdyYW5pdGVNZW51UGFuZWxJbnRlcmZhY2Uge1xuICB4UG9zaXRpb246IE1lbnVQb3NpdGlvblg7XG4gIHlQb3NpdGlvbjogTWVudVBvc2l0aW9uWTtcbiAgdGVtcGxhdGVSZWY6IFRlbXBsYXRlUmVmPGFueT47XG4gIHBhcmVudE1lbnU/OiBHcmFuaXRlTWVudVBhbmVsSW50ZXJmYWNlIHwgdW5kZWZpbmVkO1xuICBkaXJlY3Rpb24/OiBEaXJlY3Rpb247XG4gIGZvY3VzRmlyc3RJdGVtOiAob3JpZ2luPzogRm9jdXNPcmlnaW4pID0+IHZvaWQ7XG4gIGNsb3NlZDogRXZlbnRFbWl0dGVyPENsb3NlZEV2ZW50VHlwZT47XG4gIHJlYWRvbmx5IHBhbmVsSWQ/OiBzdHJpbmc7XG4gIHNob3dCYWNrQnV0dG9uOiBib29sZWFuO1xufVxuIl19

package/esm2020/lib/menu/menu-positions.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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 {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wb3NpdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2dyYW5pdGUtY29tcG9uZW50cy9zcmMvbGliL21lbnUvbWVudS1wb3NpdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCB0eXBlIE1lbnVQb3NpdGlvblggPSAnYmVmb3JlJyB8ICdhZnRlcic7XG5cbmV4cG9ydCB0eXBlIE1lbnVQb3NpdGlvblkgPSAnYWJvdmUnIHwgJ2JlbG93JztcbiJdfQ==