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

package/esm2020/menu/menu-stack.mjs

@@ -0,0 +1,156 @@
+/**
+ * @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 { Inject, Injectable, InjectionToken, Optional, SkipSelf } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/** Injection token used for an implementation of MenuStack. */
+export const MENU_STACK = new InjectionToken('cdk-menu-stack');
+/** Provider that provides the parent menu stack, or a new menu stack if there is no parent one. */
+export const PARENT_OR_NEW_MENU_STACK_PROVIDER = {
+    provide: MENU_STACK,
+    deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],
+    useFactory: (parentMenuStack) => parentMenuStack || new MenuStack(),
+};
+/** Provider that provides the parent menu stack, or a new inline menu stack if there is no parent one. */
+export const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER = (orientation) => ({
+    provide: MENU_STACK,
+    deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],
+    useFactory: (parentMenuStack) => parentMenuStack || MenuStack.inline(orientation),
+});
+/** The next available menu stack ID. */
+let nextId = 0;
+/**
+ * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off
+ * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits
+ * from the `empty` observable specifying the next focus action which the listener should perform
+ * as requested by the closer.
+ */
+export class MenuStack {
+    constructor() {
+        /** The ID of this menu stack. */
+        this.id = `${nextId++}`;
+        /** All MenuStackItems tracked by this MenuStack. */
+        this._elements = [];
+        /** Emits the element which was popped off of the stack when requested by a closer. */
+        this._close = new Subject();
+        /** Emits once the MenuStack has become empty after popping off elements. */
+        this._empty = new Subject();
+        /** Emits whether any menu in the menu stack has focus. */
+        this._hasFocus = new Subject();
+        /** Observable which emits the MenuStackItem which has been requested to close. */
+        this.closed = this._close;
+        /** Observable which emits whether any menu in the menu stack has focus. */
+        this.hasFocus = this._hasFocus.pipe(startWith(false), debounceTime(0), distinctUntilChanged());
+        /**
+         * Observable which emits when the MenuStack is empty after popping off the last element. It
+         * emits a FocusNext event which specifies the action the closer has requested the listener
+         * perform.
+         */
+        this.emptied = this._empty;
+        /**
+         * Whether the inline menu associated with this menu stack is vertical or horizontal.
+         * `null` indicates there is no inline menu associated with this menu stack.
+         */
+        this._inlineMenuOrientation = null;
+    }
+    /** Creates a menu stack that originates from an inline menu. */
+    static inline(orientation) {
+        const stack = new MenuStack();
+        stack._inlineMenuOrientation = orientation;
+        return stack;
+    }
+    /**
+     * Adds an item to the menu stack.
+     * @param menu the MenuStackItem to put on the stack.
+     */
+    push(menu) {
+        this._elements.push(menu);
+    }
+    /**
+     * Pop items off of the stack up to and including `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the last item to pop off the stack.
+     * @param options Options that configure behavior on close.
+     */
+    close(lastItem, options) {
+        const { focusNextOnEmpty, focusParentTrigger } = { ...options };
+        if (this._elements.indexOf(lastItem) >= 0) {
+            let poppedElement;
+            do {
+                poppedElement = this._elements.pop();
+                this._close.next({ item: poppedElement, focusParentTrigger });
+            } while (poppedElement !== lastItem);
+            if (this.isEmpty()) {
+                this._empty.next(focusNextOnEmpty);
+            }
+        }
+    }
+    /**
+     * Pop items off of the stack up to but excluding `lastItem` and emit each on the close
+     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
+     * @param lastItem the element which should be left on the stack
+     * @return whether or not an item was removed from the stack
+     */
+    closeSubMenuOf(lastItem) {
+        let removed = false;
+        if (this._elements.indexOf(lastItem) >= 0) {
+            removed = this.peek() !== lastItem;
+            while (this.peek() !== lastItem) {
+                this._close.next({ item: this._elements.pop() });
+            }
+        }
+        return removed;
+    }
+    /**
+     * Pop off all MenuStackItems and emit each one on the `close` observable one by one.
+     * @param options Options that configure behavior on close.
+     */
+    closeAll(options) {
+        const { focusNextOnEmpty, focusParentTrigger } = { ...options };
+        if (!this.isEmpty()) {
+            while (!this.isEmpty()) {
+                const menuStackItem = this._elements.pop();
+                if (menuStackItem) {
+                    this._close.next({ item: menuStackItem, focusParentTrigger });
+                }
+            }
+            this._empty.next(focusNextOnEmpty);
+        }
+    }
+    /** Return true if this stack is empty. */
+    isEmpty() {
+        return !this._elements.length;
+    }
+    /** Return the length of the stack. */
+    length() {
+        return this._elements.length;
+    }
+    /** Get the top most element on the stack. */
+    peek() {
+        return this._elements[this._elements.length - 1];
+    }
+    /** Whether the menu stack is associated with an inline menu. */
+    hasInlineMenu() {
+        return this._inlineMenuOrientation != null;
+    }
+    /** The orientation of the associated inline menu. */
+    inlineMenuOrientation() {
+        return this._inlineMenuOrientation;
+    }
+    /** Sets whether the menu stack contains the focused element. */
+    setHasFocus(hasFocus) {
+        this._hasFocus.next(hasFocus);
+    }
+}
+MenuStack.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.14", ngImport: i0, type: MenuStack, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MenuStack.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.0-next.14", ngImport: i0, type: MenuStack });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.14", ngImport: i0, type: MenuStack, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-stack.js","sourceRoot":"","sources":["../../../../../../src/cdk/menu/menu-stack.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 {Inject, Injectable, InjectionToken, Optional, SkipSelf} from '@angular/core';\nimport {Observable, Subject} from 'rxjs';\nimport {debounceTime, distinctUntilChanged, startWith} from 'rxjs/operators';\n\n/** The relative item in the inline menu to focus after closing all popup menus. */\nexport const enum FocusNext {\n  nextItem,\n  previousItem,\n  currentItem,\n}\n\n/** A single item (menu) in the menu stack. */\nexport interface MenuStackItem {\n  /** A reference to the menu stack this menu stack item belongs to. */\n  menuStack?: MenuStack;\n}\n\n/** Injection token used for an implementation of MenuStack. */\nexport const MENU_STACK = new InjectionToken<MenuStack>('cdk-menu-stack');\n\n/** Provider that provides the parent menu stack, or a new menu stack if there is no parent one. */\nexport const PARENT_OR_NEW_MENU_STACK_PROVIDER = {\n  provide: MENU_STACK,\n  deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],\n  useFactory: (parentMenuStack?: MenuStack) => parentMenuStack || new MenuStack(),\n};\n\n/** Provider that provides the parent menu stack, or a new inline menu stack if there is no parent one. */\nexport const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER = (\n  orientation: 'vertical' | 'horizontal',\n) => ({\n  provide: MENU_STACK,\n  deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],\n  useFactory: (parentMenuStack?: MenuStack) => parentMenuStack || MenuStack.inline(orientation),\n});\n\n/** Options that can be provided to the close or closeAll methods. */\nexport interface CloseOptions {\n  /** The element to focus next if the close operation causes the menu stack to become empty. */\n  focusNextOnEmpty?: FocusNext;\n  /** Whether to focus the parent trigger after closing the menu. */\n  focusParentTrigger?: boolean;\n}\n\n/** Event dispatched when a menu is closed. */\nexport interface MenuStackCloseEvent {\n  /** The menu being closed. */\n  item: MenuStackItem;\n  /** Whether to focus the parent trigger after closing the menu. */\n  focusParentTrigger?: boolean;\n}\n\n/** The next available menu stack ID. */\nlet nextId = 0;\n\n/**\n * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off\n * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits\n * from the `empty` observable specifying the next focus action which the listener should perform\n * as requested by the closer.\n */\n@Injectable()\nexport class MenuStack {\n  /** The ID of this menu stack. */\n  readonly id = `${nextId++}`;\n\n  /** All MenuStackItems tracked by this MenuStack. */\n  private readonly _elements: MenuStackItem[] = [];\n\n  /** Emits the element which was popped off of the stack when requested by a closer. */\n  private readonly _close = new Subject<MenuStackCloseEvent>();\n\n  /** Emits once the MenuStack has become empty after popping off elements. */\n  private readonly _empty = new Subject<FocusNext | undefined>();\n\n  /** Emits whether any menu in the menu stack has focus. */\n  private readonly _hasFocus = new Subject<boolean>();\n\n  /** Observable which emits the MenuStackItem which has been requested to close. */\n  readonly closed: Observable<MenuStackCloseEvent> = this._close;\n\n  /** Observable which emits whether any menu in the menu stack has focus. */\n  readonly hasFocus: Observable<boolean> = this._hasFocus.pipe(\n    startWith(false),\n    debounceTime(0),\n    distinctUntilChanged(),\n  );\n\n  /**\n   * Observable which emits when the MenuStack is empty after popping off the last element. It\n   * emits a FocusNext event which specifies the action the closer has requested the listener\n   * perform.\n   */\n  readonly emptied: Observable<FocusNext | undefined> = this._empty;\n\n  /**\n   * Whether the inline menu associated with this menu stack is vertical or horizontal.\n   * `null` indicates there is no inline menu associated with this menu stack.\n   */\n  private _inlineMenuOrientation: 'vertical' | 'horizontal' | null = null;\n\n  /** Creates a menu stack that originates from an inline menu. */\n  static inline(orientation: 'vertical' | 'horizontal') {\n    const stack = new MenuStack();\n    stack._inlineMenuOrientation = orientation;\n    return stack;\n  }\n\n  /**\n   * Adds an item to the menu stack.\n   * @param menu the MenuStackItem to put on the stack.\n   */\n  push(menu: MenuStackItem) {\n    this._elements.push(menu);\n  }\n\n  /**\n   * Pop items off of the stack up to and including `lastItem` and emit each on the close\n   * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.\n   * @param lastItem the last item to pop off the stack.\n   * @param options Options that configure behavior on close.\n   */\n  close(lastItem: MenuStackItem, options?: CloseOptions) {\n    const {focusNextOnEmpty, focusParentTrigger} = {...options};\n    if (this._elements.indexOf(lastItem) >= 0) {\n      let poppedElement;\n      do {\n        poppedElement = this._elements.pop()!;\n        this._close.next({item: poppedElement, focusParentTrigger});\n      } while (poppedElement !== lastItem);\n\n      if (this.isEmpty()) {\n        this._empty.next(focusNextOnEmpty);\n      }\n    }\n  }\n\n  /**\n   * Pop items off of the stack up to but excluding `lastItem` and emit each on the close\n   * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.\n   * @param lastItem the element which should be left on the stack\n   * @return whether or not an item was removed from the stack\n   */\n  closeSubMenuOf(lastItem: MenuStackItem) {\n    let removed = false;\n    if (this._elements.indexOf(lastItem) >= 0) {\n      removed = this.peek() !== lastItem;\n      while (this.peek() !== lastItem) {\n        this._close.next({item: this._elements.pop()!});\n      }\n    }\n    return removed;\n  }\n\n  /**\n   * Pop off all MenuStackItems and emit each one on the `close` observable one by one.\n   * @param options Options that configure behavior on close.\n   */\n  closeAll(options?: CloseOptions) {\n    const {focusNextOnEmpty, focusParentTrigger} = {...options};\n    if (!this.isEmpty()) {\n      while (!this.isEmpty()) {\n        const menuStackItem = this._elements.pop();\n        if (menuStackItem) {\n          this._close.next({item: menuStackItem, focusParentTrigger});\n        }\n      }\n      this._empty.next(focusNextOnEmpty);\n    }\n  }\n\n  /** Return true if this stack is empty. */\n  isEmpty() {\n    return !this._elements.length;\n  }\n\n  /** Return the length of the stack. */\n  length() {\n    return this._elements.length;\n  }\n\n  /** Get the top most element on the stack. */\n  peek(): MenuStackItem | undefined {\n    return this._elements[this._elements.length - 1];\n  }\n\n  /** Whether the menu stack is associated with an inline menu. */\n  hasInlineMenu() {\n    return this._inlineMenuOrientation != null;\n  }\n\n  /** The orientation of the associated inline menu. */\n  inlineMenuOrientation() {\n    return this._inlineMenuOrientation;\n  }\n\n  /** Sets whether the menu stack contains the focused element. */\n  setHasFocus(hasFocus: boolean) {\n    this._hasFocus.next(hasFocus);\n  }\n}\n"]}

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

@@ -0,0 +1,114 @@
+/**
+ * @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, EventEmitter, Inject, InjectionToken, Injector, ViewContainerRef, } from '@angular/core';
+import { MENU_STACK, MenuStack } from './menu-stack';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { merge, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./menu-stack";
+/** Injection token used for an implementation of MenuStack. */
+export const MENU_TRIGGER = new InjectionToken('cdk-menu-trigger');
+/**
+ * Abstract directive that implements shared logic common to all menu triggers.
+ * This class can be extended to create custom menu trigger types.
+ */
+export class CdkMenuTriggerBase {
+    constructor(
+    /** The DI injector for this component */
+    injector, 
+    /** The view container ref for this component */
+    viewContainerRef, 
+    /** The menu stack this menu is part of. */
+    menuStack) {
+        this.injector = injector;
+        this.viewContainerRef = viewContainerRef;
+        this.menuStack = menuStack;
+        /** Emits when the attached menu is requested to open */
+        this.opened = new EventEmitter();
+        /** Emits when the attached menu is requested to close */
+        this.closed = new EventEmitter();
+        /** A reference to the overlay which manages the triggered menu */
+        this.overlayRef = null;
+        /** Emits when this trigger is destroyed. */
+        this.destroyed = new Subject();
+        /** Emits when the outside pointer events listener on the overlay should be stopped. */
+        this.stopOutsideClicksListener = merge(this.closed, this.destroyed);
+    }
+    ngOnDestroy() {
+        this._destroyOverlay();
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    /** Whether the attached menu is open. */
+    isOpen() {
+        return !!this.overlayRef?.hasAttached();
+    }
+    /** Registers a child menu as having been opened by this trigger. */
+    registerChildMenu(child) {
+        this.childMenu = child;
+    }
+    /**
+     * Get the portal to be attached to the overlay which contains the menu. Allows for the menu
+     * content to change dynamically and be reflected in the application.
+     */
+    getMenuContentPortal() {
+        const hasMenuContentChanged = this.menuTemplateRef !== this._menuPortal?.templateRef;
+        if (this.menuTemplateRef && (!this._menuPortal || hasMenuContentChanged)) {
+            this._menuPortal = new TemplatePortal(this.menuTemplateRef, this.viewContainerRef, undefined, this._getChildMenuInjector());
+        }
+        return this._menuPortal;
+    }
+    /**
+     * Whether the given element is inside the scope of this trigger's menu stack.
+     * @param element The element to check.
+     * @return Whether the element is inside the scope of this trigger's menu stack.
+     */
+    isElementInsideMenuStack(element) {
+        for (let el = element; el; el = el?.parentElement ?? null) {
+            if (el.getAttribute('data-cdk-menu-stack-id') === this.menuStack.id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Destroy and unset the overlay reference it if exists */
+    _destroyOverlay() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    /** Gets the injector to use when creating a child menu. */
+    _getChildMenuInjector() {
+        this._childMenuInjector =
+            this._childMenuInjector ||
+                Injector.create({
+                    providers: [
+                        { provide: MENU_TRIGGER, useValue: this },
+                        { provide: MENU_STACK, useValue: this.menuStack },
+                    ],
+                    parent: this.injector,
+                });
+        return this._childMenuInjector;
+    }
+}
+CdkMenuTriggerBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.14", ngImport: i0, type: CdkMenuTriggerBase, deps: [{ token: i0.Injector }, { token: i0.ViewContainerRef }, { token: MENU_STACK }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuTriggerBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.14", type: CdkMenuTriggerBase, host: { properties: { "attr.aria-controls": "childMenu?.id", "attr.data-cdk-menu-stack-id": "menuStack.id" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.14", ngImport: i0, type: CdkMenuTriggerBase, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '[attr.aria-controls]': 'childMenu?.id',
+                        '[attr.data-cdk-menu-stack-id]': 'menuStack.id',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.ViewContainerRef }, { type: i1.MenuStack, decorators: [{
+                    type: Inject,
+                    args: [MENU_STACK]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-trigger-base.js","sourceRoot":"","sources":["../../../../../../src/cdk/menu/menu-trigger-base.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  EventEmitter,\n  Inject,\n  InjectionToken,\n  Injector,\n  OnDestroy,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {Menu} from './menu-interface';\nimport {MENU_STACK, MenuStack} from './menu-stack';\nimport {ConnectedPosition, OverlayRef} from '@angular/cdk/overlay';\nimport {TemplatePortal} from '@angular/cdk/portal';\nimport {merge, Subject} from 'rxjs';\n\n/** Injection token used for an implementation of MenuStack. */\nexport const MENU_TRIGGER = new InjectionToken<CdkMenuTriggerBase>('cdk-menu-trigger');\n\n/**\n * Abstract directive that implements shared logic common to all menu triggers.\n * This class can be extended to create custom menu trigger types.\n */\n@Directive({\n  host: {\n    '[attr.aria-controls]': 'childMenu?.id',\n    '[attr.data-cdk-menu-stack-id]': 'menuStack.id',\n  },\n})\nexport abstract class CdkMenuTriggerBase implements OnDestroy {\n  /** A list of preferred menu positions to be used when constructing the `FlexibleConnectedPositionStrategy` for this trigger's menu. */\n  menuPosition: ConnectedPosition[];\n\n  /** Emits when the attached menu is requested to open */\n  readonly opened: EventEmitter<void> = new EventEmitter();\n\n  /** Emits when the attached menu is requested to close */\n  readonly closed: EventEmitter<void> = new EventEmitter();\n\n  /** Template reference variable to the menu this trigger opens */\n  menuTemplateRef: TemplateRef<unknown>;\n\n  /** A reference to the overlay which manages the triggered menu */\n  protected overlayRef: OverlayRef | null = null;\n\n  /** Emits when this trigger is destroyed. */\n  protected readonly destroyed: Subject<void> = new Subject();\n\n  /** Emits when the outside pointer events listener on the overlay should be stopped. */\n  protected readonly stopOutsideClicksListener = merge(this.closed, this.destroyed);\n\n  /** The child menu opened by this trigger. */\n  protected childMenu?: Menu;\n\n  /** The content of the menu panel opened by this trigger. */\n  private _menuPortal: TemplatePortal;\n\n  /** The injector to use for the child menu opened by this trigger. */\n  private _childMenuInjector?: Injector;\n\n  protected constructor(\n    /** The DI injector for this component */\n    protected readonly injector: Injector,\n    /** The view container ref for this component */\n    protected readonly viewContainerRef: ViewContainerRef,\n    /** The menu stack this menu is part of. */\n    @Inject(MENU_STACK) protected readonly menuStack: MenuStack,\n  ) {}\n\n  ngOnDestroy() {\n    this._destroyOverlay();\n\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  /** Whether the attached menu is open. */\n  isOpen() {\n    return !!this.overlayRef?.hasAttached();\n  }\n\n  /** Registers a child menu as having been opened by this trigger. */\n  registerChildMenu(child: Menu) {\n    this.childMenu = child;\n  }\n\n  /**\n   * Get the portal to be attached to the overlay which contains the menu. Allows for the menu\n   * content to change dynamically and be reflected in the application.\n   */\n  protected getMenuContentPortal() {\n    const hasMenuContentChanged = this.menuTemplateRef !== this._menuPortal?.templateRef;\n    if (this.menuTemplateRef && (!this._menuPortal || hasMenuContentChanged)) {\n      this._menuPortal = new TemplatePortal(\n        this.menuTemplateRef,\n        this.viewContainerRef,\n        undefined,\n        this._getChildMenuInjector(),\n      );\n    }\n\n    return this._menuPortal;\n  }\n\n  /**\n   * Whether the given element is inside the scope of this trigger's menu stack.\n   * @param element The element to check.\n   * @return Whether the element is inside the scope of this trigger's menu stack.\n   */\n  protected isElementInsideMenuStack(element: Element) {\n    for (let el: Element | null = element; el; el = el?.parentElement ?? null) {\n      if (el.getAttribute('data-cdk-menu-stack-id') === this.menuStack.id) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /** Destroy and unset the overlay reference it if exists */\n  private _destroyOverlay() {\n    if (this.overlayRef) {\n      this.overlayRef.dispose();\n      this.overlayRef = null;\n    }\n  }\n\n  /** Gets the injector to use when creating a child menu. */\n  private _getChildMenuInjector() {\n    this._childMenuInjector =\n      this._childMenuInjector ||\n      Injector.create({\n        providers: [\n          {provide: MENU_TRIGGER, useValue: this},\n          {provide: MENU_STACK, useValue: this.menuStack},\n        ],\n        parent: this.injector,\n      });\n    return this._childMenuInjector;\n  }\n}\n"]}