@theseam/ui-common 0.4.0-beta.6 → 0.4.2

package/esm2020/menu/menu-toggle.directive.mjs

@@ -1,22 +1,82 @@
 import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
-import { DOWN_ARROW, ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';
+import { DOWN_ARROW, ENTER, ESCAPE, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW } from '@angular/cdk/keycodes';
 import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
 import { TemplatePortal } from '@angular/cdk/portal';
-import { Directive, HostListener, Input } from '@angular/core';
-import { merge, of, Subscription } from 'rxjs';
+import { ChangeDetectorRef, Directive, EventEmitter, HostListener, inject, Inject, Input, Optional, Output, Self } from '@angular/core';
+import { asapScheduler, delay, filter, merge, of, Subscription, take, takeUntil } from 'rxjs';
+import { THESEAM_MENU_PANEL } from './menu-panel-token';
+import { MenuComponent } from './menu.component';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/overlay";
 import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "./menu-item.component";
+import * as i4 from "@angular/cdk/bidi";
 /** Options for binding a passive event listener. */
 const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
 export class MenuToggleDirective {
+    get menu() { return this._menu; }
+    set menu(menu) {
+        if (menu === this._menu) {
+            return;
+        }
+        this._menu = menu;
+        this._menuClosedSubscription.unsubscribe();
+        if (menu) {
+            if (menu === this._parentMenuComponent && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                throw Error(`seamMenuToggle: menu cannot contain its own trigger. Assign a menu that is ` +
+                    `not a parent of the trigger or move the trigger outside of the menu.`);
+            }
+            this._menuClosedSubscription = menu.closed.subscribe((reason) => {
+                // this._destroyMenu(reason)
+                this.closeMenu();
+                // If a click closed the menu, we should close the entire chain of nested menus.
+                if ((reason === 'click' || reason === 'tab') && this._parentMenuComponent) {
+                    this._parentMenuComponent.closed.emit(reason);
+                }
+            });
+        }
+        this._menuItemInstance?._setTriggersSubmenu(this.triggersSubmenu());
+    }
     set positions(val) {
         this._positions = val;
         if (this.menuOpen()) {
             this._overlayRef?.updatePositionStrategy(this.getOverlayPosition(this._elementRef.nativeElement));
         }
     }
-    get positions() { return this._positions; }
+    get positions() {
+        const positions = this._positions;
+        if (this.triggersSubmenu()) {
+            return [
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'top',
+                    offsetY: -11,
+                },
+                {
+                    originX: 'end',
+                    originY: 'top',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                    offsetY: -11,
+                },
+                {
+                    originX: 'start',
+                    originY: 'bottom',
+                    overlayX: 'end',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'start',
+                    overlayY: 'bottom',
+                },
+            ];
+        }
+        return positions;
+    }
     _onMouseDown(event) {
         if (!isFakeMousedownFromScreenReader(event)) {
             // Since right or middle button clicks won't trigger the `click` event,
@@ -25,41 +85,63 @@ export class MenuToggleDirective {
             // Since clicking on the trigger won't close the menu if it opens a sub-menu,
             // we should prevent focus from moving onto it via click to avoid the
             // highlight from lingering on the menu item.
-            // if (this.triggersSubmenu()) {
-            //   event.preventDefault();
-            // }
+            if (this.triggersSubmenu()) {
+                event.preventDefault();
+            }
         }
     }
     _onKeydown(event) {
         this._openedBy = null;
+        // console.log('keydown', event)
         // tslint:disable-next-line:deprecation
         const keyCode = event.keyCode;
         if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {
             if (this.menuOpen()) {
-                this.seamMenuToggle?.focusFirstItem(this._openedBy || 'program');
+                this.menu?.focusFirstItem(this._openedBy || 'program');
             }
         }
+        else if (keyCode === ESCAPE) {
+            this.closeMenu();
+        }
+        // Pressing enter on the trigger will trigger the click handler later.
+        if (keyCode === ENTER || keyCode === SPACE) {
+            this._openedBy = 'keyboard';
+        }
+        if (this.triggersSubmenu() &&
+            ((keyCode === RIGHT_ARROW && this.dir === 'ltr') ||
+                (keyCode === LEFT_ARROW && this.dir === 'rtl'))) {
+            this._openedBy = 'keyboard';
+            this.openMenu();
+        }
     }
     _onClick(event) {
-        this.toggle();
+        if (this.triggersSubmenu()) {
+            // Stop event propagation to avoid closing the parent menu.
+            event.stopPropagation();
+            this.openMenu();
+        }
+        else {
+            this.toggle();
+        }
     }
     _onDocumentKeydown(event) {
         if (event.keyCode === ESCAPE) {
             this.closeMenu();
         }
     }
-    // @HostListener('document:mousedown', [ '$event' ])
-    // _onDocumentMouseDown(event: any) {
-    //   console.log('outside click')
-    // }
-    constructor(_elementRef, _viewContainerRef, _overlay, _focusMonitor) {
+    constructor(_elementRef, _viewContainerRef, _overlay, _focusMonitor, _parentMenu, _menuItemInstance, _dir) {
         this._elementRef = _elementRef;
         this._viewContainerRef = _viewContainerRef;
         this._overlay = _overlay;
         this._focusMonitor = _focusMonitor;
+        this._parentMenu = _parentMenu;
+        this._menuItemInstance = _menuItemInstance;
+        this._dir = _dir;
         this._active = false;
         this._menuClosedSubscription = Subscription.EMPTY;
         this._closingActionsSubscription = Subscription.EMPTY;
+        this._hoverSubscription = Subscription.EMPTY;
+        this._changeDetectorRef = inject(ChangeDetectorRef);
         this.restoreFocus = true;
         // Tracking input type is necessary so it's possible to only auto-focus
         // the first item of the list when the menu is opened via the keyboard
@@ -90,11 +172,16 @@ export class MenuToggleDirective {
                 overlayY: 'bottom',
             },
         ];
+        /** Event emitted when the associated menu is opened. */
+        this.menuOpened = new EventEmitter();
+        /** Event emitted when the associated menu is opened. */
+        this.menuClosed = new EventEmitter();
         /**
          * Handles touch start events on the trigger.
          * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.
          */
         this._handleTouchStart = () => this._openedBy = 'touch';
+        this._parentMenuComponent = this._parentMenu instanceof MenuComponent ? this._parentMenu : undefined;
         this._elementRef.nativeElement.addEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
     }
     ngOnDestroy() {
@@ -102,6 +189,10 @@ export class MenuToggleDirective {
         this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
         this._menuClosedSubscription.unsubscribe();
         this._closingActionsSubscription.unsubscribe();
+        this._hoverSubscription.unsubscribe();
+    }
+    ngAfterContentInit() {
+        this._handleHover();
     }
     toggle() {
         if (this._active) {
@@ -112,23 +203,23 @@ export class MenuToggleDirective {
         }
     }
     openMenu() {
-        if (this._active || !this.seamMenuToggle) {
+        if (this._active || !this.menu) {
             return;
         }
         this._active = true;
         this._overlayRef = this._overlay.create({
-            hasBackdrop: true,
-            backdropClass: 'transparent',
+            hasBackdrop: !this._parentMenuComponent,
+            backdropClass: 'cdk-overlay-transparent-backdrop',
             positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),
         });
-        const tpl = this.seamMenuToggle.templateRef;
+        const tpl = this.menu.templateRef;
         if (!tpl) {
             throw Error(`Menu template not found.`);
         }
         this._overlayRef.attach(new TemplatePortal(tpl, this._viewContainerRef));
         this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu());
-        this._initMenu();
-        this._menuClosedSubscription = this.seamMenuToggle.closed.subscribe(v => {
+        this._initMenu(this.menu);
+        this._menuClosedSubscription = this.menu.closed.subscribe(v => {
             // console.log('closed', v)
             this.closeMenu();
         });
@@ -136,10 +227,22 @@ export class MenuToggleDirective {
         //   console.log('backdropClick', v)
         // })
     }
+    /** The text direction of the containing app. */
+    get dir() {
+        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+    }
+    /** Whether the menu triggers a sub-menu or a top-level one. */
+    triggersSubmenu() {
+        return !!(this._menuItemInstance && this._parentMenuComponent && this.menu);
+    }
     closeMenu() {
         if (!this._active) {
             return;
         }
+        let emitCloseEvent = false;
+        if (this.menuOpen()) {
+            emitCloseEvent = true;
+        }
         if (this._overlayRef?.hasAttached()) {
             this._overlayRef?.detach();
         }
@@ -147,6 +250,9 @@ export class MenuToggleDirective {
         this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
         this._menuClosedSubscription.unsubscribe();
         this._closingActionsSubscription.unsubscribe();
+        if (emitCloseEvent) {
+            this.menu?.closed.emit();
+        }
         this._active = false;
     }
     menuOpen() {
@@ -176,19 +282,19 @@ export class MenuToggleDirective {
      * This method sets the menu state to open and focuses the first item if
      * the menu was opened via the keyboard.
      */
-    _initMenu() {
-        // this.seamMenuToggle.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined
-        // this.seamMenuToggle.direction = this.dir
-        // this._setMenuElevation()
-        // this._setIsMenuOpen(true)
-        // this.seamMenuToggle.focusFirstItem(this._openedBy || 'program')
+    _initMenu(menu) {
+        menu.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined;
+        menu.direction = this.dir;
+        // this._setMenuElevation(menu)
+        menu.focusFirstItem(this._openedBy || 'program');
+        this._setIsMenuOpen(true);
     }
     /**
      * This method resets the menu when it's closed, most importantly restoring
      * focus to the menu trigger if the menu was opened via the keyboard.
      */
     _resetMenu() {
-        // this._setIsMenuOpen(false)
+        this._setIsMenuOpen(false);
         // We should reset focus if the user is navigating using a keyboard or
         // if we have a top-level trigger which might cause focus to be lost
         // when clicking on the backdrop.
@@ -198,43 +304,96 @@ export class MenuToggleDirective {
                 // `keyboard` so we don't have to specify which one it is.
                 this.focus();
             }
-            // else if (!this.triggersSubmenu()) {
-            //   this.focus(this._openedBy)
-            // }
+            else if (!this.triggersSubmenu()) {
+                this.focus(this._openedBy);
+            }
         }
         this._openedBy = null;
     }
+    // set state rather than toggle to support triggers sharing a menu
+    _setIsMenuOpen(isOpen) {
+        if (isOpen !== this.menuOpen()) {
+            // this._menuOpen = isOpen
+            this.menuOpen() ? this.menuOpened.emit() : this.menuClosed.emit();
+            if (this.triggersSubmenu()) {
+                this._menuItemInstance?._setHighlighted(isOpen);
+            }
+            this._changeDetectorRef.markForCheck();
+        }
+    }
     /** Returns a stream that emits whenever an action that should close the menu occurs. */
     _menuClosingActions() {
         const backdrop = this._overlayRef?.backdropClick() ?? of();
         const detachments = this._overlayRef?.detachments() ?? of();
-        // const parentClose = this._parentMenu ? this._parentMenu.closed : of()
-        const parentClose = of();
-        // const hover = this._parentMenu ? this._parentMenu._hovered().pipe(
-        //   filter(active => active !== this._menuItemInstance),
-        //   filter(() => this._menuOpen)
-        // ) : of()
-        const hover = of();
+        const parentClose = this._parentMenu ? this._parentMenu.closed : of();
+        const hover = this._parentMenuComponent ? this._parentMenuComponent._hovered().pipe(filter(active => active !== this._menuItemInstance), filter(() => this.menuOpen())) : of();
         return merge(backdrop, parentClose, hover, detachments);
     }
+    /** Handles the cases where the user hovers over the trigger. */
+    _handleHover() {
+        // Subscribe to changes in the hovered item in order to toggle the panel.
+        if (!this.triggersSubmenu() || !this._parentMenuComponent) {
+            return;
+        }
+        this._hoverSubscription = this._parentMenuComponent
+            ._hovered()
+            // Since we might have multiple competing triggers for the same menu (e.g. a sub-menu
+            // with different data and triggers), we have to delay it by a tick to ensure that
+            // it won't be closed immediately after it is opened.
+            .pipe(filter(active => active === this._menuItemInstance && !active.disabled), delay(0, asapScheduler))
+            .subscribe(() => {
+            this._openedBy = 'mouse';
+            // If the same menu is used between multiple triggers, it might still be animating
+            // while the new trigger tries to re-open it. Wait for the animation to finish
+            // before doing so. Also interrupt if the user moves to another item.
+            if (this.menu instanceof MenuComponent && this.menu._isAnimating) {
+                // We need the `delay(0)` here in order to avoid
+                // 'changed after checked' errors in some cases. See #12194.
+                this.menu._animationDone
+                    .pipe(take(1), delay(0, asapScheduler), takeUntil(this._parentMenuComponent._hovered()))
+                    .subscribe(() => this.openMenu());
+            }
+            else {
+                this.openMenu();
+            }
+        });
+    }
 }
-MenuToggleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: MenuToggleDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.Overlay }, { token: i2.FocusMonitor }], target: i0.ɵɵFactoryTarget.Directive });
-MenuToggleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.6", type: MenuToggleDirective, selector: "[seamMenuToggle]", inputs: { seamMenuToggle: "seamMenuToggle", positions: "positions" }, host: { attributes: { "aria-haspopup": "true" }, listeners: { "mousedown": "_onMouseDown($event)", "keydown": "_onKeydown($event)", "click": "_onClick($event)", "document:keydown": "_onDocumentKeydown($event)" }, properties: { "attr.aria-expanded": "menuOpen() || null" } }, exportAs: ["seamMenuToggle"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: MenuToggleDirective, decorators: [{
+MenuToggleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MenuToggleDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.Overlay }, { token: i2.FocusMonitor }, { token: THESEAM_MENU_PANEL, optional: true }, { token: i3.MenuItemComponent, optional: true, self: true }, { token: i4.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+MenuToggleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: MenuToggleDirective, selector: "[seamMenuToggle]", inputs: { menu: ["seamMenuToggle", "menu"], positions: "positions" }, outputs: { menuOpened: "menuOpened", menuClosed: "menuClosed" }, host: { attributes: { "aria-haspopup": "true" }, listeners: { "mousedown": "_onMouseDown($event)", "keydown": "_onKeydown($event)", "click": "_onClick($event)", "document:keydown": "_onDocumentKeydown($event)" }, properties: { "attr.aria-expanded": "menuOpen() || null", "attr.aria-controls": "menuOpen() ? menu.panelId : null" }, classAttribute: "seam-menu-toggle" }, exportAs: ["seamMenuToggle"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MenuToggleDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[seamMenuToggle]',
                     // tslint:disable-next-line:use-host-property-decorator
                     host: {
+                        'class': 'seam-menu-toggle',
                         'aria-haspopup': 'true',
-                        '[attr.aria-expanded]': 'menuOpen() || null'
+                        '[attr.aria-expanded]': 'menuOpen() || null',
+                        '[attr.aria-controls]': 'menuOpen() ? menu.panelId : null',
                     },
                     exportAs: 'seamMenuToggle'
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.Overlay }, { type: i2.FocusMonitor }]; }, propDecorators: { seamMenuToggle: [{
-                type: Input
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.Overlay }, { type: i2.FocusMonitor }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_MENU_PANEL]
+                }, {
+                    type: Optional
+                }] }, { type: i3.MenuItemComponent, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i4.Directionality, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { menu: [{
+                type: Input,
+                args: ['seamMenuToggle']
             }], positions: [{
                 type: Input
+            }], menuOpened: [{
+                type: Output
+            }], menuClosed: [{
+                type: Output
             }], _onMouseDown: [{
                 type: HostListener,
                 args: ['mousedown', ['$event']]
@@ -248,4 +407,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImpor
                 type: HostListener,
                 args: ['document:keydown', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-toggle.directive.js","sourceRoot":"","sources":["../../../../projects/ui-common/menu/menu-toggle.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor, FocusOrigin, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y'\nimport { DOWN_ARROW, ESCAPE, UP_ARROW } from '@angular/cdk/keycodes'\nimport { ConnectionPositionPair, Overlay, OverlayRef, PositionStrategy } from '@angular/cdk/overlay'\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform'\nimport { TemplatePortal } from '@angular/cdk/portal'\nimport { Directive, ElementRef, HostListener, Inject, Input, OnDestroy, Optional, ViewContainerRef } from '@angular/core'\nimport { merge, of, Subscription } from 'rxjs'\n\nimport { MenuItemComponent } from './menu-item.component'\nimport { ITheSeamMenuPanel } from './menu-panel'\nimport { THESEAM_MENU_PANEL } from './menu-panel-token'\nimport { MenuComponent } from './menu.component'\n\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({passive: true})\n\n@Directive({\n  selector: '[seamMenuToggle]',\n  // tslint:disable-next-line:use-host-property-decorator\n  host: {\n    'aria-haspopup': 'true',\n    '[attr.aria-expanded]': 'menuOpen() || null'\n  },\n  exportAs: 'seamMenuToggle'\n})\nexport class MenuToggleDirective implements OnDestroy {\n\n  private _active = false\n  private _overlayRef?: OverlayRef\n  private _menuClosedSubscription = Subscription.EMPTY\n  private _closingActionsSubscription = Subscription.EMPTY\n\n  public restoreFocus = true\n\n  // Tracking input type is necessary so it's possible to only auto-focus\n  // the first item of the list when the menu is opened via the keyboard\n  _openedBy: 'mouse' | 'touch' | null = null\n\n  @Input() seamMenuToggle: MenuComponent | undefined | null\n\n  @Input()\n  set positions(val: ConnectionPositionPair[]) {\n    this._positions = val\n    if (this.menuOpen()) {\n      this._overlayRef?.updatePositionStrategy(this.getOverlayPosition(this._elementRef.nativeElement))\n    }\n  }\n  get positions() { return this._positions }\n  private _positions: ConnectionPositionPair[] = [\n    {\n      originX: 'end',\n      originY: 'bottom',\n      overlayX: 'end',\n      overlayY: 'top',\n    },\n    {\n      originX: 'start',\n      originY: 'bottom',\n      overlayX: 'start',\n      overlayY: 'top',\n    },\n    {\n      originX: 'end',\n      originY: 'top',\n      overlayX: 'end',\n      overlayY: 'bottom',\n    },\n    {\n      originX: 'start',\n      originY: 'top',\n      overlayX: 'start',\n      overlayY: 'bottom',\n    },\n  ]\n\n  @HostListener('mousedown', [ '$event' ])\n  _onMouseDown(event: MouseEvent) {\n    if (!isFakeMousedownFromScreenReader(event)) {\n      // Since right or middle button clicks won't trigger the `click` event,\n      // we shouldn't consider the menu as opened by mouse in those cases.\n      this._openedBy = event.button === 0 ? 'mouse' : null\n\n      // Since clicking on the trigger won't close the menu if it opens a sub-menu,\n      // we should prevent focus from moving onto it via click to avoid the\n      // highlight from lingering on the menu item.\n      // if (this.triggersSubmenu()) {\n      //   event.preventDefault();\n      // }\n    }\n  }\n\n  @HostListener('keydown', [ '$event' ])\n  _onKeydown(event: any) {\n    this._openedBy = null\n\n    // tslint:disable-next-line:deprecation\n    const keyCode = event.keyCode\n\n    if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {\n      if (this.menuOpen()) {\n        this.seamMenuToggle?.focusFirstItem(this._openedBy || 'program')\n      }\n    }\n  }\n\n  @HostListener('click', [ '$event' ])\n  _onClick(event: any) {\n    this.toggle()\n  }\n\n  @HostListener('document:keydown', [ '$event' ])\n  _onDocumentKeydown(event: any) {\n    if (event.keyCode === ESCAPE) {\n      this.closeMenu()\n    }\n  }\n\n  // @HostListener('document:mousedown', [ '$event' ])\n  // _onDocumentMouseDown(event: any) {\n  //   console.log('outside click')\n  // }\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _viewContainerRef: ViewContainerRef,\n    private _overlay: Overlay,\n    private _focusMonitor: FocusMonitor,\n    // @Inject(THESEAM_MENU_PANEL) @Optional() private _parentMenu?: ITheSeamMenuPanel<MenuItemComponent>\n  ) {\n    this._elementRef.nativeElement.addEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n  }\n\n  ngOnDestroy() {\n    this.closeMenu()\n\n    this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n\n    this._menuClosedSubscription.unsubscribe()\n    this._closingActionsSubscription.unsubscribe()\n  }\n\n  /**\n   * Handles touch start events on the trigger.\n   * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.\n   */\n  private _handleTouchStart = () => this._openedBy = 'touch'\n\n  public toggle(): void {\n    if (this._active) {\n      this.closeMenu()\n    } else {\n      this.openMenu()\n    }\n  }\n\n  public openMenu(): void {\n    if (this._active || !this.seamMenuToggle) { return }\n    this._active = true\n\n    this._overlayRef = this._overlay.create({\n      hasBackdrop: true,\n      backdropClass: 'transparent',\n      positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),\n    })\n\n    const tpl = this.seamMenuToggle.templateRef\n    if (!tpl) {\n      throw Error(`Menu template not found.`)\n    }\n\n    this._overlayRef.attach(new TemplatePortal(tpl, this._viewContainerRef))\n\n    this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu())\n    this._initMenu()\n\n    this._menuClosedSubscription = this.seamMenuToggle.closed.subscribe(v => {\n      // console.log('closed', v)\n      this.closeMenu()\n    })\n\n    // this._overlayRef.backdropClick().subscribe(v => {\n    //   console.log('backdropClick', v)\n    // })\n  }\n\n  public closeMenu(): void {\n    if (!this._active) { return }\n\n    if (this._overlayRef?.hasAttached()) {\n      this._overlayRef?.detach()\n    }\n\n    this._resetMenu()\n\n    this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n\n    this._menuClosedSubscription.unsubscribe()\n    this._closingActionsSubscription.unsubscribe()\n\n    this._active = false\n  }\n\n  public menuOpen(): boolean {\n    return (this._overlayRef && this._overlayRef.hasAttached()) ?? false\n  }\n\n  private getOverlayPosition(origin: HTMLElement): PositionStrategy {\n    const positionStrategy = this._overlay.position()\n      .flexibleConnectedTo(origin)\n      .withPositions(this.positions)\n      .withFlexibleDimensions(false)\n      .withPush(true)\n\n    return positionStrategy\n  }\n\n  /**\n   * Focuses the menu trigger.\n   * @param origin Source of the menu trigger's focus.\n   */\n  focus(origin: FocusOrigin = 'program') {\n    if (this._focusMonitor) {\n      this._focusMonitor.focusVia(this._elementRef, origin)\n    } else {\n      this._elementRef.nativeElement.focus()\n    }\n  }\n\n  /**\n   * This method sets the menu state to open and focuses the first item if\n   * the menu was opened via the keyboard.\n   */\n  private _initMenu(): void {\n    // this.seamMenuToggle.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined\n    // this.seamMenuToggle.direction = this.dir\n    // this._setMenuElevation()\n    // this._setIsMenuOpen(true)\n    // this.seamMenuToggle.focusFirstItem(this._openedBy || 'program')\n  }\n\n  /**\n   * This method resets the menu when it's closed, most importantly restoring\n   * focus to the menu trigger if the menu was opened via the keyboard.\n   */\n  private _resetMenu(): void {\n    // this._setIsMenuOpen(false)\n\n    // We should reset focus if the user is navigating using a keyboard or\n    // if we have a top-level trigger which might cause focus to be lost\n    // when clicking on the backdrop.\n    if (this.restoreFocus) {\n      if (!this._openedBy) {\n        // Note that the focus style will show up both for `program` and\n        // `keyboard` so we don't have to specify which one it is.\n        this.focus()\n      }\n      // else if (!this.triggersSubmenu()) {\n      //   this.focus(this._openedBy)\n      // }\n    }\n\n    this._openedBy = null\n  }\n\n  /** Returns a stream that emits whenever an action that should close the menu occurs. */\n  private _menuClosingActions() {\n    const backdrop = this._overlayRef?.backdropClick() ?? of()\n    const detachments = this._overlayRef?.detachments() ?? of()\n    // const parentClose = this._parentMenu ? this._parentMenu.closed : of()\n    const parentClose = of()\n    // const hover = this._parentMenu ? this._parentMenu._hovered().pipe(\n    //   filter(active => active !== this._menuItemInstance),\n    //   filter(() => this._menuOpen)\n    // ) : of()\n    const hover = of()\n\n    return merge(backdrop, parentClose, hover, detachments)\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-toggle.directive.js","sourceRoot":"","sources":["../../../../projects/ui-common/menu/menu-toggle.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor, FocusOrigin, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y'\nimport { Direction, Directionality } from '@angular/cdk/bidi'\nimport { DOWN_ARROW, ENTER, ESCAPE, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW } from '@angular/cdk/keycodes'\nimport { ConnectionPositionPair, Overlay, OverlayRef, PositionStrategy } from '@angular/cdk/overlay'\nimport { normalizePassiveListenerOptions } from '@angular/cdk/platform'\nimport { TemplatePortal } from '@angular/cdk/portal'\nimport { AfterContentInit, ChangeDetectorRef, Directive, ElementRef, EventEmitter, HostListener, inject, Inject, Input, OnDestroy, Optional, Output, Self, ViewContainerRef } from '@angular/core'\nimport { asapScheduler, delay, filter, merge, Observable, of, Subscription, take, takeUntil } from 'rxjs'\n\nimport { MenuItemComponent } from './menu-item.component'\nimport { ITheSeamMenuPanel } from './menu-panel'\nimport { THESEAM_MENU_PANEL } from './menu-panel-token'\nimport { MenuCloseReason, MenuComponent } from './menu.component'\n\ndeclare const ngDevMode: any\n\n/** Options for binding a passive event listener. */\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true })\n\n@Directive({\n  selector: '[seamMenuToggle]',\n  // tslint:disable-next-line:use-host-property-decorator\n  host: {\n    'class': 'seam-menu-toggle',\n    'aria-haspopup': 'true',\n    '[attr.aria-expanded]': 'menuOpen() || null',\n    '[attr.aria-controls]': 'menuOpen() ? menu.panelId : null',\n  },\n  exportAs: 'seamMenuToggle'\n})\nexport class MenuToggleDirective implements OnDestroy, AfterContentInit {\n\n  private _active = false\n  private _overlayRef?: OverlayRef\n  private _menuClosedSubscription = Subscription.EMPTY\n  private _closingActionsSubscription = Subscription.EMPTY\n  private _hoverSubscription = Subscription.EMPTY\n  private readonly _changeDetectorRef = inject(ChangeDetectorRef)\n\n  public restoreFocus = true\n\n  // Tracking input type is necessary so it's possible to only auto-focus\n  // the first item of the list when the menu is opened via the keyboard\n  _openedBy: 'mouse' | 'touch' | 'keyboard' | null = null\n\n  @Input('seamMenuToggle')\n  get menu() { return this._menu }\n  set menu(menu: MenuComponent | undefined | null) {\n    if (menu === this._menu) {\n      return\n    }\n\n    this._menu = menu\n    this._menuClosedSubscription.unsubscribe()\n\n    if (menu) {\n      if (menu === this._parentMenuComponent && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n        throw Error(\n          `seamMenuToggle: menu cannot contain its own trigger. Assign a menu that is ` +\n          `not a parent of the trigger or move the trigger outside of the menu.`,\n        )\n      }\n\n      this._menuClosedSubscription = menu.closed.subscribe((reason: MenuCloseReason) => {\n        // this._destroyMenu(reason)\n        this.closeMenu()\n\n        // If a click closed the menu, we should close the entire chain of nested menus.\n        if ((reason === 'click' || reason === 'tab') && this._parentMenuComponent) {\n          this._parentMenuComponent.closed.emit(reason)\n        }\n      })\n    }\n\n    this._menuItemInstance?._setTriggersSubmenu(this.triggersSubmenu())\n  }\n  _menu: MenuComponent | undefined | null\n\n  @Input()\n  set positions(val: ConnectionPositionPair[]) {\n    this._positions = val\n    if (this.menuOpen()) {\n      this._overlayRef?.updatePositionStrategy(this.getOverlayPosition(this._elementRef.nativeElement))\n    }\n  }\n  get positions() {\n    const positions = this._positions\n\n    if (this.triggersSubmenu()) {\n      return [\n        {\n          originX: 'start',\n          originY: 'top',\n          overlayX: 'end',\n          overlayY: 'top',\n          offsetY: -11,\n        },\n        {\n          originX: 'end',\n          originY: 'top',\n          overlayX: 'start',\n          overlayY: 'top',\n          offsetY: -11,\n        },\n        {\n          originX: 'start',\n          originY: 'bottom',\n          overlayX: 'end',\n          overlayY: 'top',\n        },\n        {\n          originX: 'start',\n          originY: 'top',\n          overlayX: 'start',\n          overlayY: 'bottom',\n        },\n      ]\n    }\n\n    return positions\n  }\n  private _positions: ConnectionPositionPair[] = [\n    {\n      originX: 'end',\n      originY: 'bottom',\n      overlayX: 'end',\n      overlayY: 'top',\n    },\n    {\n      originX: 'start',\n      originY: 'bottom',\n      overlayX: 'start',\n      overlayY: 'top',\n    },\n    {\n      originX: 'end',\n      originY: 'top',\n      overlayX: 'end',\n      overlayY: 'bottom',\n    },\n    {\n      originX: 'start',\n      originY: 'top',\n      overlayX: 'start',\n      overlayY: 'bottom',\n    },\n  ]\n\n  /** Event emitted when the associated menu is opened. */\n  @Output() readonly menuOpened = new EventEmitter<void>()\n\n  /** Event emitted when the associated menu is opened. */\n  @Output() readonly menuClosed = new EventEmitter<void>()\n\n  @HostListener('mousedown', [ '$event' ])\n  _onMouseDown(event: MouseEvent) {\n    if (!isFakeMousedownFromScreenReader(event)) {\n      // Since right or middle button clicks won't trigger the `click` event,\n      // we shouldn't consider the menu as opened by mouse in those cases.\n      this._openedBy = event.button === 0 ? 'mouse' : null\n\n      // Since clicking on the trigger won't close the menu if it opens a sub-menu,\n      // we should prevent focus from moving onto it via click to avoid the\n      // highlight from lingering on the menu item.\n      if (this.triggersSubmenu()) {\n        event.preventDefault()\n      }\n    }\n  }\n\n  @HostListener('keydown', [ '$event' ])\n  _onKeydown(event: any) {\n    this._openedBy = null\n    // console.log('keydown', event)\n\n    // tslint:disable-next-line:deprecation\n    const keyCode = event.keyCode\n\n    if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {\n      if (this.menuOpen()) {\n        this.menu?.focusFirstItem(this._openedBy || 'program')\n      }\n    } else if (keyCode === ESCAPE) {\n      this.closeMenu()\n    }\n\n    // Pressing enter on the trigger will trigger the click handler later.\n    if (keyCode === ENTER || keyCode === SPACE) {\n      this._openedBy = 'keyboard'\n    }\n\n    if (\n      this.triggersSubmenu() &&\n      ((keyCode === RIGHT_ARROW && this.dir === 'ltr') ||\n        (keyCode === LEFT_ARROW && this.dir === 'rtl'))\n    ) {\n      this._openedBy = 'keyboard'\n      this.openMenu()\n    }\n  }\n\n  @HostListener('click', [ '$event' ])\n  _onClick(event: any) {\n    if (this.triggersSubmenu()) {\n      // Stop event propagation to avoid closing the parent menu.\n      event.stopPropagation()\n      this.openMenu()\n    } else {\n      this.toggle()\n    }\n  }\n\n  @HostListener('document:keydown', [ '$event' ])\n  _onDocumentKeydown(event: any) {\n    if (event.keyCode === ESCAPE) {\n      this.closeMenu()\n    }\n  }\n\n  // @HostListener('document:mousedown', [ '$event' ])\n  // _onDocumentMouseDown(event: any) {\n  //   console.log('outside click')\n  // }\n\n  private readonly _parentMenuComponent?: MenuComponent\n\n  constructor(\n    private readonly _elementRef: ElementRef<HTMLElement>,\n    private readonly _viewContainerRef: ViewContainerRef,\n    private readonly _overlay: Overlay,\n    private readonly _focusMonitor: FocusMonitor,\n    @Inject(THESEAM_MENU_PANEL) @Optional() private readonly _parentMenu?: ITheSeamMenuPanel<MenuItemComponent>,\n    @Optional() @Self() private readonly _menuItemInstance?: MenuItemComponent,\n    @Optional() private readonly _dir?: Directionality,\n  ) {\n    this._parentMenuComponent = this._parentMenu instanceof MenuComponent ? this._parentMenu : undefined\n\n    this._elementRef.nativeElement.addEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n  }\n\n  ngOnDestroy() {\n    this.closeMenu()\n\n    this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n\n    this._menuClosedSubscription.unsubscribe()\n    this._closingActionsSubscription.unsubscribe()\n    this._hoverSubscription.unsubscribe()\n  }\n\n  ngAfterContentInit() {\n    this._handleHover()\n  }\n\n  /**\n   * Handles touch start events on the trigger.\n   * Needs to be an arrow function so we can easily use addEventListener and removeEventListener.\n   */\n  private _handleTouchStart = () => this._openedBy = 'touch'\n\n  public toggle(): void {\n    if (this._active) {\n      this.closeMenu()\n    } else {\n      this.openMenu()\n    }\n  }\n\n  public openMenu(): void {\n    if (this._active || !this.menu) { return }\n    this._active = true\n\n    this._overlayRef = this._overlay.create({\n      hasBackdrop: !this._parentMenuComponent,\n      backdropClass: 'cdk-overlay-transparent-backdrop',\n      positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),\n    })\n\n    const tpl = this.menu.templateRef\n    if (!tpl) {\n      throw Error(`Menu template not found.`)\n    }\n\n    this._overlayRef.attach(new TemplatePortal(tpl, this._viewContainerRef))\n\n    this._closingActionsSubscription = this._menuClosingActions().subscribe(() => this.closeMenu())\n    this._initMenu(this.menu)\n\n    this._menuClosedSubscription = this.menu.closed.subscribe(v => {\n      // console.log('closed', v)\n      this.closeMenu()\n    })\n\n    // this._overlayRef.backdropClick().subscribe(v => {\n    //   console.log('backdropClick', v)\n    // })\n  }\n\n  /** The text direction of the containing app. */\n  get dir(): Direction {\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr'\n  }\n\n  /** Whether the menu triggers a sub-menu or a top-level one. */\n  triggersSubmenu(): boolean {\n    return !!(this._menuItemInstance && this._parentMenuComponent && this.menu)\n  }\n\n  public closeMenu(): void {\n    if (!this._active) { return }\n    let emitCloseEvent = false\n    if (this.menuOpen()) {\n      emitCloseEvent = true\n    }\n\n    if (this._overlayRef?.hasAttached()) {\n      this._overlayRef?.detach()\n    }\n\n    this._resetMenu()\n\n    this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart,\n        passiveEventListenerOptions)\n\n    this._menuClosedSubscription.unsubscribe()\n    this._closingActionsSubscription.unsubscribe()\n\n    if (emitCloseEvent) {\n      this.menu?.closed.emit()\n    }\n\n    this._active = false\n  }\n\n  public menuOpen(): boolean {\n    return (this._overlayRef && this._overlayRef.hasAttached()) ?? false\n  }\n\n  private getOverlayPosition(origin: HTMLElement): PositionStrategy {\n    const positionStrategy = this._overlay.position()\n      .flexibleConnectedTo(origin)\n      .withPositions(this.positions)\n      .withFlexibleDimensions(false)\n      .withPush(true)\n\n    return positionStrategy\n  }\n\n  /**\n   * Focuses the menu trigger.\n   * @param origin Source of the menu trigger's focus.\n   */\n  focus(origin: FocusOrigin = 'program') {\n    if (this._focusMonitor) {\n      this._focusMonitor.focusVia(this._elementRef, origin)\n    } else {\n      this._elementRef.nativeElement.focus()\n    }\n  }\n\n  /**\n   * This method sets the menu state to open and focuses the first item if\n   * the menu was opened via the keyboard.\n   */\n  private _initMenu(menu: MenuComponent): void {\n    menu.parentMenu = this.triggersSubmenu() ? this._parentMenu : undefined\n    menu.direction = this.dir\n    // this._setMenuElevation(menu)\n    menu.focusFirstItem(this._openedBy || 'program')\n    this._setIsMenuOpen(true)\n  }\n\n  /**\n   * This method resets the menu when it's closed, most importantly restoring\n   * focus to the menu trigger if the menu was opened via the keyboard.\n   */\n  private _resetMenu(): void {\n    this._setIsMenuOpen(false)\n\n    // We should reset focus if the user is navigating using a keyboard or\n    // if we have a top-level trigger which might cause focus to be lost\n    // when clicking on the backdrop.\n    if (this.restoreFocus) {\n      if (!this._openedBy) {\n        // Note that the focus style will show up both for `program` and\n        // `keyboard` so we don't have to specify which one it is.\n        this.focus()\n      } else if (!this.triggersSubmenu()) {\n        this.focus(this._openedBy)\n      }\n    }\n\n    this._openedBy = null\n  }\n\n  // set state rather than toggle to support triggers sharing a menu\n  private _setIsMenuOpen(isOpen: boolean): void {\n    if (isOpen !== this.menuOpen()) {\n      // this._menuOpen = isOpen\n      this.menuOpen() ? this.menuOpened.emit() : this.menuClosed.emit()\n\n      if (this.triggersSubmenu()) {\n        this._menuItemInstance?._setHighlighted(isOpen)\n      }\n\n      this._changeDetectorRef.markForCheck()\n    }\n  }\n\n  /** Returns a stream that emits whenever an action that should close the menu occurs. */\n  private _menuClosingActions() {\n    const backdrop = this._overlayRef?.backdropClick() ?? of()\n    const detachments = this._overlayRef?.detachments() ?? of()\n    const parentClose = this._parentMenu ? this._parentMenu.closed : of()\n    const hover = this._parentMenuComponent ? this._parentMenuComponent._hovered().pipe(\n      filter(active => active !== this._menuItemInstance),\n      filter(() => this.menuOpen())\n    ) : of()\n\n    return merge(backdrop, parentClose as Observable<MenuCloseReason>, hover, detachments)\n  }\n\n  /** Handles the cases where the user hovers over the trigger. */\n  private _handleHover() {\n    // Subscribe to changes in the hovered item in order to toggle the panel.\n    if (!this.triggersSubmenu() || !this._parentMenuComponent) {\n      return\n    }\n\n    this._hoverSubscription = this._parentMenuComponent\n      ._hovered()\n      // Since we might have multiple competing triggers for the same menu (e.g. a sub-menu\n      // with different data and triggers), we have to delay it by a tick to ensure that\n      // it won't be closed immediately after it is opened.\n      .pipe(\n        filter(active => active === this._menuItemInstance && !active.disabled),\n        delay(0, asapScheduler),\n      )\n      .subscribe(() => {\n        this._openedBy = 'mouse'\n\n        // If the same menu is used between multiple triggers, it might still be animating\n        // while the new trigger tries to re-open it. Wait for the animation to finish\n        // before doing so. Also interrupt if the user moves to another item.\n        if (this.menu instanceof MenuComponent && this.menu._isAnimating) {\n          // We need the `delay(0)` here in order to avoid\n          // 'changed after checked' errors in some cases. See #12194.\n          this.menu._animationDone\n            .pipe(take(1), delay(0, asapScheduler), takeUntil(this._parentMenuComponent!._hovered()))\n            .subscribe(() => this.openMenu())\n        } else {\n          this.openMenu()\n        }\n      })\n  }\n}\n"]}