@ethlete/cdk 4.28.0 → 4.28.2

package/esm2022/lib/components/overlay/components/menu-deprecated/menu-item.mjs

@@ -0,0 +1,216 @@
+/* eslint-disable @angular-eslint/directive-class-suffix */
+/* eslint-disable @angular-eslint/no-output-rename */
+/* eslint-disable @angular-eslint/no-outputs-metadata-property */
+/* eslint-disable @angular-eslint/no-input-rename */
+/* eslint-disable @angular-eslint/no-inputs-metadata-property */
+import { InputModalityDetector } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, hasModifierKey } from '@angular/cdk/keycodes';
+import { Directive, ElementRef, EventEmitter, Input, NgZone, Output, inject } from '@angular/core';
+import { Subject, fromEvent } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { MENU_AIM } from './menu-aim';
+import { CDK_MENU } from './menu-interface';
+import { MENU_STACK } from './menu-stack';
+import { CdkMenuTrigger } from './menu-trigger';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated Use the new menu instead
+ */
+export class CdkMenuItem {
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    get hasMenu() {
+        return this._menuTrigger?.menuTemplateRef != null;
+    }
+    constructor() {
+        this._dir = inject(Directionality, { optional: true });
+        this._inputModalityDetector = inject(InputModalityDetector);
+        this._elementRef = inject(ElementRef);
+        this._ngZone = inject(NgZone);
+        this._menuAim = inject(MENU_AIM, { optional: true });
+        this._menuStack = inject(MENU_STACK);
+        this._parentMenu = inject(CDK_MENU, { optional: true });
+        this._menuTrigger = inject(CdkMenuTrigger, { optional: true, self: true });
+        this._disabled = false;
+        this.typeaheadLabel = null;
+        this.triggered = new EventEmitter();
+        this._tabindex = -1;
+        this.closeOnSpacebarTrigger = true;
+        this.destroyed = new Subject();
+        this._setupMouseEnter();
+        this._setType();
+        if (this._isStandaloneItem()) {
+            this._tabindex = 0;
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    trigger(options) {
+        const { keepOpen } = { ...options };
+        if (!this.disabled && !this.hasMenu) {
+            this.triggered.next();
+            if (!keepOpen) {
+                this._menuStack.closeAll({ focusParentTrigger: true });
+            }
+        }
+    }
+    isMenuOpen() {
+        return !!this._menuTrigger?.isOpen();
+    }
+    getMenu() {
+        return this._menuTrigger?.getMenu();
+    }
+    getMenuTrigger() {
+        return this._menuTrigger;
+    }
+    getLabel() {
+        return this.typeaheadLabel || this._elementRef.nativeElement.textContent?.trim() || '';
+    }
+    getParentMenu() {
+        return this._parentMenu;
+    }
+    _resetTabIndex() {
+        if (!this._isStandaloneItem()) {
+            this._tabindex = -1;
+        }
+    }
+    _setTabIndex(event) {
+        if (this.disabled) {
+            return;
+        }
+        if (!event || !this._menuStack.isEmpty()) {
+            this._tabindex = 0;
+        }
+    }
+    _onKeydown(event) {
+        switch (event.keyCode) {
+            case SPACE:
+            case ENTER:
+                if (!hasModifierKey(event)) {
+                    this.trigger({ keepOpen: event.keyCode === SPACE && !this.closeOnSpacebarTrigger });
+                }
+                break;
+            case RIGHT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && this._isParentVertical()) {
+                        if (this._dir?.value !== 'rtl') {
+                            this._forwardArrowPressed(event);
+                        }
+                        else {
+                            this._backArrowPressed(event);
+                        }
+                    }
+                }
+                break;
+            case LEFT_ARROW:
+                if (!hasModifierKey(event)) {
+                    if (this._parentMenu && this._isParentVertical()) {
+                        if (this._dir?.value !== 'rtl') {
+                            this._backArrowPressed(event);
+                        }
+                        else {
+                            this._forwardArrowPressed(event);
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    _handleClick() {
+        if (this._inputModalityDetector.mostRecentModality !== 'keyboard') {
+            this.trigger();
+        }
+    }
+    _handleMousedown(event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    _isStandaloneItem() {
+        return !this._parentMenu;
+    }
+    _backArrowPressed(event) {
+        const parentMenu = this._parentMenu;
+        if (this._menuStack.hasInlineMenu() || this._menuStack.length() > 1) {
+            event.preventDefault();
+            this._menuStack.close(parentMenu, {
+                focusNextOnEmpty: this._menuStack.inlineMenuOrientation() === 'horizontal' ? 1 /* FocusNext.previousItem */ : 2 /* FocusNext.currentItem */,
+                focusParentTrigger: true,
+            });
+        }
+    }
+    _forwardArrowPressed(event) {
+        if (!this.hasMenu && this._menuStack.inlineMenuOrientation() === 'horizontal') {
+            event.preventDefault();
+            this._menuStack.closeAll({
+                focusNextOnEmpty: 0 /* FocusNext.nextItem */,
+                focusParentTrigger: true,
+            });
+        }
+    }
+    _setupMouseEnter() {
+        if (!this._isStandaloneItem()) {
+            const closeOpenSiblings = () => this._ngZone.run(() => this._menuStack.closeSubMenuOf(this._parentMenu));
+            this._ngZone.runOutsideAngular(() => fromEvent(this._elementRef.nativeElement, 'mouseenter')
+                .pipe(filter(() => !this._menuStack.isEmpty() && !this.hasMenu), takeUntil(this.destroyed))
+                .subscribe(() => {
+                if (this._menuAim) {
+                    this._menuAim.toggle(closeOpenSiblings);
+                }
+                else {
+                    closeOpenSiblings();
+                }
+            }));
+        }
+    }
+    _isParentVertical() {
+        return this._parentMenu?.orientation === 'vertical';
+    }
+    _setType() {
+        const element = this._elementRef.nativeElement;
+        if (element.nodeName === 'BUTTON' && !element.getAttribute('type')) {
+            element.setAttribute('type', 'button');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuItem, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", type: CdkMenuItem, isStandalone: true, selector: "[cdkMenuItem]", inputs: { disabled: ["cdkMenuItemDisabled", "disabled"], typeaheadLabel: ["cdkMenuitemTypeaheadLabel", "typeaheadLabel"] }, outputs: { triggered: "cdkMenuItemTriggered" }, host: { attributes: { "role": "menuitem" }, listeners: { "blur": "_resetTabIndex()", "focus": "_setTabIndex()", "click": "_handleClick()", "mousedown": "_handleMousedown($event)", "keydown": "_onKeydown($event)" }, properties: { "tabindex": "_tabindex", "attr.aria-disabled": "disabled || null" }, classAttribute: "cdk-menu-item" }, exportAs: ["cdkMenuItem"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuItem, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuItem]',
+                    exportAs: 'cdkMenuItem',
+                    standalone: true,
+                    host: {
+                        role: 'menuitem',
+                        class: 'cdk-menu-item',
+                        '[tabindex]': '_tabindex',
+                        '[attr.aria-disabled]': 'disabled || null',
+                        '(blur)': '_resetTabIndex()',
+                        '(focus)': '_setTabIndex()',
+                        '(click)': '_handleClick()',
+                        '(mousedown)': '_handleMousedown($event)',
+                        '(keydown)': '_onKeydown($event)',
+                    },
+                }]
+        }], ctorParameters: () => [], propDecorators: { disabled: [{
+                type: Input,
+                args: ['cdkMenuItemDisabled']
+            }], typeaheadLabel: [{
+                type: Input,
+                args: ['cdkMenuitemTypeaheadLabel']
+            }], triggered: [{
+                type: Output,
+                args: ['cdkMenuItemTriggered']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-item.js","sourceRoot":"","sources":["../../../../../../../../../libs/cdk/src/lib/components/overlay/components/menu-deprecated/menu-item.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/directive-class-suffix */\n/* eslint-disable @angular-eslint/no-output-rename */\n/* eslint-disable @angular-eslint/no-outputs-metadata-property */\n/* eslint-disable @angular-eslint/no-input-rename */\n/* eslint-disable @angular-eslint/no-inputs-metadata-property */\n\nimport { FocusableOption, InputModalityDetector } from '@angular/cdk/a11y';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { Directive, ElementRef, EventEmitter, Input, NgZone, OnDestroy, Output, inject } from '@angular/core';\nimport { Subject, fromEvent } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { MENU_AIM, Toggler } from './menu-aim';\nimport { CDK_MENU, Menu } from './menu-interface';\nimport { FocusNext, MENU_STACK } from './menu-stack';\nimport { CdkMenuTrigger } from './menu-trigger';\nimport { FocusableElement } from './pointer-focus-tracker';\n\n/**\n * @deprecated Use the new menu instead\n */\n@Directive({\n  selector: '[cdkMenuItem]',\n  exportAs: 'cdkMenuItem',\n  standalone: true,\n  host: {\n    role: 'menuitem',\n    class: 'cdk-menu-item',\n    '[tabindex]': '_tabindex',\n    '[attr.aria-disabled]': 'disabled || null',\n    '(blur)': '_resetTabIndex()',\n    '(focus)': '_setTabIndex()',\n    '(click)': '_handleClick()',\n    '(mousedown)': '_handleMousedown($event)',\n    '(keydown)': '_onKeydown($event)',\n  },\n})\nexport class CdkMenuItem implements FocusableOption, FocusableElement, Toggler, OnDestroy {\n  protected readonly _dir = inject(Directionality, { optional: true });\n  private readonly _inputModalityDetector = inject(InputModalityDetector);\n  readonly _elementRef: ElementRef<HTMLElement> = inject(ElementRef);\n  protected _ngZone = inject(NgZone);\n\n  private readonly _menuAim = inject(MENU_AIM, { optional: true });\n\n  private readonly _menuStack = inject(MENU_STACK);\n\n  private readonly _parentMenu = inject(CDK_MENU, { optional: true });\n\n  private readonly _menuTrigger = inject(CdkMenuTrigger, { optional: true, self: true });\n\n  @Input('cdkMenuItemDisabled')\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled = false;\n\n  @Input('cdkMenuitemTypeaheadLabel') typeaheadLabel: string | null = null;\n\n  @Output('cdkMenuItemTriggered') readonly triggered: EventEmitter<void> = new EventEmitter();\n\n  get hasMenu() {\n    return this._menuTrigger?.menuTemplateRef != null;\n  }\n\n  _tabindex: 0 | -1 = -1;\n\n  protected closeOnSpacebarTrigger = true;\n\n  protected readonly destroyed = new Subject<void>();\n\n  constructor() {\n    this._setupMouseEnter();\n    this._setType();\n\n    if (this._isStandaloneItem()) {\n      this._tabindex = 0;\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  focus() {\n    this._elementRef.nativeElement.focus();\n  }\n\n  trigger(options?: { keepOpen: boolean }) {\n    const { keepOpen } = { ...options };\n    if (!this.disabled && !this.hasMenu) {\n      this.triggered.next();\n      if (!keepOpen) {\n        this._menuStack.closeAll({ focusParentTrigger: true });\n      }\n    }\n  }\n\n  isMenuOpen() {\n    return !!this._menuTrigger?.isOpen();\n  }\n\n  getMenu(): Menu | undefined {\n    return this._menuTrigger?.getMenu();\n  }\n\n  getMenuTrigger(): CdkMenuTrigger | null {\n    return this._menuTrigger;\n  }\n\n  getLabel(): string {\n    return this.typeaheadLabel || this._elementRef.nativeElement.textContent?.trim() || '';\n  }\n\n  getParentMenu() {\n    return this._parentMenu;\n  }\n\n  _resetTabIndex() {\n    if (!this._isStandaloneItem()) {\n      this._tabindex = -1;\n    }\n  }\n\n  _setTabIndex(event?: MouseEvent) {\n    if (this.disabled) {\n      return;\n    }\n\n    if (!event || !this._menuStack.isEmpty()) {\n      this._tabindex = 0;\n    }\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    switch (event.keyCode) {\n      case SPACE:\n      case ENTER:\n        if (!hasModifierKey(event)) {\n          this.trigger({ keepOpen: event.keyCode === SPACE && !this.closeOnSpacebarTrigger });\n        }\n        break;\n\n      case RIGHT_ARROW:\n        if (!hasModifierKey(event)) {\n          if (this._parentMenu && this._isParentVertical()) {\n            if (this._dir?.value !== 'rtl') {\n              this._forwardArrowPressed(event);\n            } else {\n              this._backArrowPressed(event);\n            }\n          }\n        }\n        break;\n\n      case LEFT_ARROW:\n        if (!hasModifierKey(event)) {\n          if (this._parentMenu && this._isParentVertical()) {\n            if (this._dir?.value !== 'rtl') {\n              this._backArrowPressed(event);\n            } else {\n              this._forwardArrowPressed(event);\n            }\n          }\n        }\n        break;\n    }\n  }\n\n  _handleClick() {\n    if (this._inputModalityDetector.mostRecentModality !== 'keyboard') {\n      this.trigger();\n    }\n  }\n\n  _handleMousedown(event: MouseEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  private _isStandaloneItem() {\n    return !this._parentMenu;\n  }\n\n  private _backArrowPressed(event: KeyboardEvent) {\n    const parentMenu = this._parentMenu!;\n    if (this._menuStack.hasInlineMenu() || this._menuStack.length() > 1) {\n      event.preventDefault();\n      this._menuStack.close(parentMenu, {\n        focusNextOnEmpty:\n          this._menuStack.inlineMenuOrientation() === 'horizontal' ? FocusNext.previousItem : FocusNext.currentItem,\n        focusParentTrigger: true,\n      });\n    }\n  }\n\n  private _forwardArrowPressed(event: KeyboardEvent) {\n    if (!this.hasMenu && this._menuStack.inlineMenuOrientation() === 'horizontal') {\n      event.preventDefault();\n      this._menuStack.closeAll({\n        focusNextOnEmpty: FocusNext.nextItem,\n        focusParentTrigger: true,\n      });\n    }\n  }\n\n  private _setupMouseEnter() {\n    if (!this._isStandaloneItem()) {\n      const closeOpenSiblings = () => this._ngZone.run(() => this._menuStack.closeSubMenuOf(this._parentMenu!));\n\n      this._ngZone.runOutsideAngular(() =>\n        fromEvent(this._elementRef.nativeElement, 'mouseenter')\n          .pipe(\n            filter(() => !this._menuStack.isEmpty() && !this.hasMenu),\n            takeUntil(this.destroyed),\n          )\n          .subscribe(() => {\n            if (this._menuAim) {\n              this._menuAim.toggle(closeOpenSiblings);\n            } else {\n              closeOpenSiblings();\n            }\n          }),\n      );\n    }\n  }\n\n  private _isParentVertical() {\n    return this._parentMenu?.orientation === 'vertical';\n  }\n\n  private _setType() {\n    const element = this._elementRef.nativeElement;\n\n    if (element.nodeName === 'BUTTON' && !element.getAttribute('type')) {\n      element.setAttribute('type', 'button');\n    }\n  }\n}\n"]}

package/esm2022/lib/components/overlay/components/menu-deprecated/menu-module.mjs

@@ -0,0 +1,58 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { NgModule } from '@angular/core';
+import { CdkContextMenuTrigger } from './context-menu-trigger';
+import { CdkMenu } from './menu';
+import { CdkTargetMenuAim } from './menu-aim';
+import { CdkMenuBar } from './menu-bar';
+import { CdkMenuGroup } from './menu-group';
+import { CdkMenuItem } from './menu-item';
+import { CdkMenuItemCheckbox } from './menu-item-checkbox';
+import { CdkMenuItemRadio } from './menu-item-radio';
+import { CdkMenuTrigger } from './menu-trigger';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated Use the new menu instead
+ */
+const MENU_DIRECTIVES = [
+    CdkMenuBar,
+    CdkMenu,
+    CdkMenuItem,
+    CdkMenuItemRadio,
+    CdkMenuItemCheckbox,
+    CdkMenuTrigger,
+    CdkMenuGroup,
+    CdkContextMenuTrigger,
+    CdkTargetMenuAim,
+];
+/**
+ * @deprecated Use the new menu instead
+ */
+export class CdkMenuModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuModule, imports: [OverlayModule, CdkMenuBar,
+            CdkMenu,
+            CdkMenuItem,
+            CdkMenuItemRadio,
+            CdkMenuItemCheckbox,
+            CdkMenuTrigger,
+            CdkMenuGroup,
+            CdkContextMenuTrigger,
+            CdkTargetMenuAim], exports: [CdkMenuBar,
+            CdkMenu,
+            CdkMenuItem,
+            CdkMenuItemRadio,
+            CdkMenuItemCheckbox,
+            CdkMenuTrigger,
+            CdkMenuGroup,
+            CdkContextMenuTrigger,
+            CdkTargetMenuAim] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuModule, imports: [OverlayModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OverlayModule, ...MENU_DIRECTIVES],
+                    exports: MENU_DIRECTIVES,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/overlay/components/menu-deprecated/menu-stack.mjs

@@ -0,0 +1,104 @@
+/* eslint-disable @angular-eslint/directive-class-suffix */
+/* eslint-disable @angular-eslint/no-output-rename */
+/* eslint-disable @angular-eslint/no-outputs-metadata-property */
+/* eslint-disable @angular-eslint/no-input-rename */
+/* eslint-disable @angular-eslint/no-inputs-metadata-property */
+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";
+export const MENU_STACK = new InjectionToken('cdk-menu-stack');
+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(),
+};
+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),
+});
+let nextId = 0;
+/**
+ * @deprecated Use the new menu instead
+ */
+export class MenuStack {
+    constructor() {
+        this.id = `${nextId++}`;
+        this._elements = [];
+        this._close = new Subject();
+        this._empty = new Subject();
+        this._hasFocus = new Subject();
+        this.closed = this._close;
+        this.hasFocus = this._hasFocus.pipe(startWith(false), debounceTime(0), distinctUntilChanged());
+        this.emptied = this._empty;
+        this._inlineMenuOrientation = null;
+    }
+    static inline(orientation) {
+        const stack = new MenuStack();
+        stack._inlineMenuOrientation = orientation;
+        return stack;
+    }
+    push(menu) {
+        this._elements.push(menu);
+    }
+    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);
+            }
+        }
+    }
+    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;
+    }
+    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);
+        }
+    }
+    isEmpty() {
+        return !this._elements.length;
+    }
+    length() {
+        return this._elements.length;
+    }
+    peek() {
+        return this._elements[this._elements.length - 1];
+    }
+    hasInlineMenu() {
+        return this._inlineMenuOrientation != null;
+    }
+    inlineMenuOrientation() {
+        return this._inlineMenuOrientation;
+    }
+    setHasFocus(hasFocus) {
+        this._hasFocus.next(hasFocus);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: MenuStack, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: MenuStack }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: MenuStack, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-stack.js","sourceRoot":"","sources":["../../../../../../../../../libs/cdk/src/lib/components/overlay/components/menu-deprecated/menu-stack.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/directive-class-suffix */\n/* eslint-disable @angular-eslint/no-output-rename */\n/* eslint-disable @angular-eslint/no-outputs-metadata-property */\n/* eslint-disable @angular-eslint/no-input-rename */\n/* eslint-disable @angular-eslint/no-inputs-metadata-property */\n\nimport { Inject, Injectable, InjectionToken, Optional, SkipSelf } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, startWith } from 'rxjs/operators';\n\nexport const enum FocusNext {\n  nextItem,\n  previousItem,\n  currentItem,\n}\n\nexport interface MenuStackItem {\n  menuStack?: MenuStack;\n}\n\nexport const MENU_STACK = new InjectionToken<MenuStack>('cdk-menu-stack');\n\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\nexport const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER = (orientation: 'vertical' | 'horizontal') => ({\n  provide: MENU_STACK,\n  deps: [[new Optional(), new SkipSelf(), new Inject(MENU_STACK)]],\n  useFactory: (parentMenuStack?: MenuStack) => parentMenuStack || MenuStack.inline(orientation),\n});\n\nexport interface CloseOptions {\n  focusNextOnEmpty?: FocusNext;\n  focusParentTrigger?: boolean;\n}\n\nexport interface MenuStackCloseEvent {\n  item: MenuStackItem;\n  focusParentTrigger?: boolean;\n}\n\nlet nextId = 0;\n\n/**\n * @deprecated Use the new menu instead\n */\n@Injectable()\nexport class MenuStack {\n  readonly id = `${nextId++}`;\n\n  private readonly _elements: MenuStackItem[] = [];\n\n  private readonly _close = new Subject<MenuStackCloseEvent>();\n\n  private readonly _empty = new Subject<FocusNext | undefined>();\n\n  private readonly _hasFocus = new Subject<boolean>();\n\n  readonly closed: Observable<MenuStackCloseEvent> = this._close;\n\n  readonly hasFocus: Observable<boolean> = this._hasFocus.pipe(\n    startWith(false),\n    debounceTime(0),\n    distinctUntilChanged(),\n  );\n\n  readonly emptied: Observable<FocusNext | undefined> = this._empty;\n\n  private _inlineMenuOrientation: 'vertical' | 'horizontal' | null = null;\n\n  static inline(orientation: 'vertical' | 'horizontal') {\n    const stack = new MenuStack();\n    stack._inlineMenuOrientation = orientation;\n    return stack;\n  }\n\n  push(menu: MenuStackItem) {\n    this._elements.push(menu);\n  }\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  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  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  isEmpty() {\n    return !this._elements.length;\n  }\n\n  length() {\n    return this._elements.length;\n  }\n\n  peek(): MenuStackItem | undefined {\n    return this._elements[this._elements.length - 1];\n  }\n\n  hasInlineMenu() {\n    return this._inlineMenuOrientation != null;\n  }\n\n  inlineMenuOrientation() {\n    return this._inlineMenuOrientation;\n  }\n\n  setHasFocus(hasFocus: boolean) {\n    this._hasFocus.next(hasFocus);\n  }\n}\n"]}

package/esm2022/lib/components/overlay/components/menu-deprecated/menu-trigger-base.mjs

@@ -0,0 +1,80 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Directive, EventEmitter, InjectionToken, Injector, ViewContainerRef, inject, } from '@angular/core';
+import { Subject, merge } from 'rxjs';
+import { MENU_STACK } from './menu-stack';
+import * as i0 from "@angular/core";
+export const MENU_TRIGGER = new InjectionToken('cdk-menu-trigger');
+/**
+ * @deprecated Use the new menu instead
+ */
+export class CdkMenuTriggerBase {
+    constructor() {
+        this.injector = inject(Injector);
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.menuStack = inject(MENU_STACK);
+        this.menuPosition = null;
+        this.opened = new EventEmitter();
+        this.closed = new EventEmitter();
+        this.menuTemplateRef = null;
+        this.overlayRef = null;
+        this.destroyed = new Subject();
+        this.stopOutsideClicksListener = merge(this.closed, this.destroyed);
+        this._menuPortal = null;
+    }
+    ngOnDestroy() {
+        this._destroyOverlay();
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    isOpen() {
+        return !!this.overlayRef?.hasAttached();
+    }
+    registerChildMenu(child) {
+        this.childMenu = child;
+    }
+    getMenuContentPortal() {
+        const hasMenuContentChanged = this.menuTemplateRef !== this._menuPortal?.templateRef;
+        if (this.menuTemplateRef && (!this._menuPortal || hasMenuContentChanged)) {
+            this._menuPortal = new TemplatePortal(this.menuTemplateRef, this.viewContainerRef, this.menuData, this._getChildMenuInjector());
+        }
+        return this._menuPortal;
+    }
+    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;
+    }
+    _destroyOverlay() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    _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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: CdkMenuTriggerBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", 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: "18.0.6", ngImport: i0, type: CdkMenuTriggerBase, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        '[attr.aria-controls]': 'childMenu?.id',
+                        '[attr.data-cdk-menu-stack-id]': 'menuStack.id',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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