@theseam/ui-common 0.2.9

package/esm2015/menu/menu-footer-action/menu-footer-action.component.js

@@ -0,0 +1,48 @@
+import { ChangeDetectionStrategy, Component, ElementRef, HostBinding, Input } from '@angular/core';
+// TODO: Split up the button and anchor classes.
+export class MenuFooterActionComponent {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+    }
+    get _attrType() { return this.type; }
+    /** ARIA type for the button. */
+    get type() { return this._isButton() ? this._type || 'button' : undefined; }
+    set type(value) {
+        this._type = value;
+    }
+    get _classBtn() { return this._isButton(); }
+    get _classBtnLink() { return this._isButton(); }
+    get _stylePadding() { return this._isButton() && 0; }
+    get _styleBorder() { return this._isButton() && 0; }
+    get _styleDisplay() { return this._isButton() && 'inline'; }
+    /** Determines if the component host is a button. */
+    _isButton() {
+        return this._elementRef.nativeElement.nodeName.toLowerCase() === 'button';
+    }
+    /** Determines if the component host is an anchor. */
+    _isAnchor() {
+        return this._elementRef.nativeElement.nodeName.toLowerCase() === 'a';
+    }
+}
+MenuFooterActionComponent.decorators = [
+    { type: Component, args: [{
+                // tslint:disable-next-line:component-selector
+                selector: 'button[seamMenuFooterAction],a[seamMenuFooterAction]',
+                template: "<ng-content></ng-content>\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+MenuFooterActionComponent.ctorParameters = () => [
+    { type: ElementRef }
+];
+MenuFooterActionComponent.propDecorators = {
+    _attrType: [{ type: HostBinding, args: ['attr.type',] }],
+    type: [{ type: Input }],
+    _classBtn: [{ type: HostBinding, args: ['class.btn',] }],
+    _classBtnLink: [{ type: HostBinding, args: ['class.btn-link',] }],
+    _stylePadding: [{ type: HostBinding, args: ['style.padding.px',] }],
+    _styleBorder: [{ type: HostBinding, args: ['style.border.px',] }],
+    _styleDisplay: [{ type: HostBinding, args: ['style.display.px',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/menu/menu-header/menu-header.component.js

@@ -0,0 +1,32 @@
+import { ChangeDetectionStrategy, Component, Inject, Optional } from '@angular/core';
+import { THESEAM_MENU_PANEL } from '../menu-panel-token';
+export class MenuHeaderComponent {
+    constructor(_parentMenu) {
+        this._parentMenu = _parentMenu;
+    }
+    ngOnInit() {
+        if (this._parentMenu && this._parentMenu.setHeader) {
+            this._parentMenu.setHeader(this);
+        }
+    }
+    ngOnDestroy() {
+        if (this._parentMenu && this._parentMenu.setHeader) {
+            this._parentMenu.setHeader(undefined);
+        }
+    }
+}
+MenuHeaderComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-menu-header',
+                template: "<ng-content></ng-content>\n",
+                host: {
+                    'class': 'd-flex flex-column bg-light border-bottom rounded-top py-2 mb-2'
+                },
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+MenuHeaderComponent.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [THESEAM_MENU_PANEL,] }, { type: Optional }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/menu/menu-item.component.js

@@ -0,0 +1,127 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, HostListener, Inject, Input, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { mixinDisabled } from '@theseam/ui-common/core';
+import { THESEAM_MENU_PANEL } from './menu-panel-token';
+class TheSeamMenuItemBase {
+}
+const _seamMenuItemMixinBase = mixinDisabled(TheSeamMenuItemBase);
+export class MenuItemComponent extends _seamMenuItemMixinBase {
+    constructor(_elementRef, document, _focusMonitor, _parentMenu) {
+        super();
+        this._elementRef = _elementRef;
+        this.document = document;
+        this._focusMonitor = _focusMonitor;
+        this._parentMenu = _parentMenu;
+        /** ARIA role for the menu item. */
+        this.role = 'menuitem';
+        this.badgeTheme = 'danger';
+        /** Stream that emits when the menu item is hovered. */
+        this._hovered = new Subject();
+        /** Whether the menu item is highlighted. */
+        this._highlighted = false;
+        if (_focusMonitor) {
+            // Start monitoring the element so it gets the appropriate focused classes. We want
+            // to show the focus style for menu items only when the focus was not caused by a
+            // mouse or touch interaction.
+            _focusMonitor.monitor(this._elementRef, false);
+        }
+        // console.log(this._parentMenu)
+        if (_parentMenu && _parentMenu.addItem) {
+            _parentMenu.addItem(this);
+        }
+    }
+    ngOnInit() { }
+    ngOnDestroy() {
+        if (this._focusMonitor) {
+            this._focusMonitor.stopMonitoring(this._elementRef);
+        }
+        if (this._parentMenu && this._parentMenu.removeItem) {
+            this._parentMenu.removeItem(this);
+        }
+        this._hovered.complete();
+    }
+    /** Focuses the menu item. */
+    focus(origin = 'program') {
+        if (this._focusMonitor) {
+            this._focusMonitor.focusVia(this._getHostElement(), origin);
+        }
+        else {
+            this._getHostElement().focus();
+        }
+    }
+    /** Used to set the `tabindex`. */
+    _getTabIndex() {
+        return this.disabled ? '-1' : '0';
+    }
+    /** Returns the host DOM element. */
+    _getHostElement() {
+        return this._elementRef.nativeElement;
+    }
+    /** Prevents the default element actions if it is disabled. */
+    _checkDisabled(event) {
+        if (this.disabled) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    }
+    /** Emits to the hover stream. */
+    _handleMouseEnter() {
+        this._hovered.next(this);
+    }
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel() {
+        const element = this._elementRef.nativeElement;
+        const textNodeType = this.document ? this.document.TEXT_NODE : 3;
+        let output = '';
+        if (element.childNodes) {
+            const length = element.childNodes.length;
+            // Go through all the top-level text nodes and extract their text.
+            // We skip anything that's not a text node to prevent the text from
+            // being thrown off by something like an icon.
+            for (let i = 0; i < length; i++) {
+                if (element.childNodes[i].nodeType === textNodeType) {
+                    output += element.childNodes[i].textContent;
+                }
+            }
+        }
+        return output.trim();
+    }
+}
+MenuItemComponent.decorators = [
+    { type: Component, args: [{
+                // tslint:disable-next-line:component-selector
+                selector: '[seamMenuItem]',
+                template: "<div class=\"d-flex flex-row\">\n  <seam-icon *ngIf=\"icon\"\n    style=\"width: 30px; height: 20px; flex: 0 0 auto;\"\n    class=\"pr-2\"\n    [icon]=\"icon\"\n    [iconClass]=\"iconClass\"\n    iconType=\"image-fill\">\n  </seam-icon>\n  <!-- <span class=\"text-nowrap\">\n    <ng-content></ng-content>\n  </span> -->\n  <div class=\"text-truncate\">\n    <ng-content></ng-content>\n  </div>\n\n  <div *ngIf=\"badgeText\">\n    <span class=\"badge badge-pill{{ badgeTheme ? ' badge-' + badgeTheme : '' }} position-relative\"\n      style=\"top: -8px\"\n      >{{ badgeText }}</span>\n  </div>\n</div>\n",
+                exportAs: 'seamMenuItem',
+                // tslint:disable-next-line:use-input-property-decorator
+                inputs: ['disabled'],
+                // tslint:disable-next-line:use-host-property-decorator
+                host: {
+                    '[attr.role]': 'role',
+                    'class': 'dropdown-item',
+                    '[attr.tabindex]': '_getTabIndex()',
+                    '[attr.aria-disabled]': 'disabled.toString()',
+                    '[attr.disabled]': 'disabled || null',
+                },
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+MenuItemComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: FocusMonitor },
+    { type: undefined, decorators: [{ type: Inject, args: [THESEAM_MENU_PANEL,] }, { type: Optional }] }
+];
+MenuItemComponent.propDecorators = {
+    role: [{ type: Input }],
+    icon: [{ type: Input }],
+    iconClass: [{ type: Input }],
+    badgeText: [{ type: Input }],
+    badgeTheme: [{ type: Input }],
+    _checkDisabled: [{ type: HostListener, args: ['click', ['$event'],] }],
+    _handleMouseEnter: [{ type: HostListener, args: ['mouseenter',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-item.component.js","sourceRoot":"","sources":["../../../../projects/ui-common/menu/menu-item.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusableOption, FocusMonitor, FocusOrigin } from '@angular/cdk/a11y'\nimport { DOCUMENT } from '@angular/common'\nimport { ChangeDetectionStrategy, Component, ElementRef, HostListener, Inject, Input, OnDestroy, OnInit, Optional } from '@angular/core'\nimport { Subject } from 'rxjs'\n\nimport { CanDisableCtor, mixinDisabled } from '@theseam/ui-common/core'\nimport { SeamIcon } from '@theseam/ui-common/icon'\n\nimport type { ITheSeamMenuPanel } from './menu-panel'\nimport { THESEAM_MENU_PANEL } from './menu-panel-token'\n\nclass TheSeamMenuItemBase {}\n\nconst _seamMenuItemMixinBase: CanDisableCtor & typeof TheSeamMenuItemBase =\n    mixinDisabled(TheSeamMenuItemBase)\n\n@Component({\n  // tslint:disable-next-line:component-selector\n  selector: '[seamMenuItem]',\n  templateUrl: './menu-item.component.html',\n  styleUrls: ['./menu-item.component.scss'],\n  exportAs: 'seamMenuItem',\n  // tslint:disable-next-line:use-input-property-decorator\n  inputs: [ 'disabled' ],\n  // tslint:disable-next-line:use-host-property-decorator\n  host: {\n    '[attr.role]': 'role',\n    'class': 'dropdown-item',\n    '[attr.tabindex]': '_getTabIndex()',\n    '[attr.aria-disabled]': 'disabled.toString()',\n    '[attr.disabled]': 'disabled || null',\n  },\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class MenuItemComponent extends _seamMenuItemMixinBase implements OnInit, OnDestroy, FocusableOption {\n\n  /** ARIA role for the menu item. */\n  @Input() role: 'menuitem' | 'menuitemradio' | 'menuitemcheckbox' | undefined | null = 'menuitem'\n\n  @Input() icon: SeamIcon | string | undefined | null\n  @Input() iconClass: string | undefined | null\n\n  @Input() badgeText: string | undefined | null\n  @Input() badgeTheme: string | undefined | null = 'danger'\n\n  /** Stream that emits when the menu item is hovered. */\n  readonly _hovered: Subject<MenuItemComponent> = new Subject<MenuItemComponent>()\n\n  /** Whether the menu item is highlighted. */\n  _highlighted = false\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    @Inject(DOCUMENT) public document: any,\n    private _focusMonitor: FocusMonitor,\n    @Inject(THESEAM_MENU_PANEL) @Optional() private _parentMenu?: ITheSeamMenuPanel<MenuItemComponent>\n  ) {\n    super()\n\n    if (_focusMonitor) {\n      // Start monitoring the element so it gets the appropriate focused classes. We want\n      // to show the focus style for menu items only when the focus was not caused by a\n      // mouse or touch interaction.\n      _focusMonitor.monitor(this._elementRef, false)\n    }\n\n    // console.log(this._parentMenu)\n    if (_parentMenu && _parentMenu.addItem) {\n      _parentMenu.addItem(this)\n    }\n  }\n\n  ngOnInit() { }\n\n  ngOnDestroy() {\n    if (this._focusMonitor) {\n      this._focusMonitor.stopMonitoring(this._elementRef)\n    }\n\n    if (this._parentMenu && this._parentMenu.removeItem) {\n      this._parentMenu.removeItem(this)\n    }\n\n    this._hovered.complete()\n  }\n\n  /** Focuses the menu item. */\n  focus(origin: FocusOrigin = 'program'): void {\n    if (this._focusMonitor) {\n      this._focusMonitor.focusVia(this._getHostElement(), origin)\n    } else {\n      this._getHostElement().focus()\n    }\n  }\n\n  /** Used to set the `tabindex`. */\n  _getTabIndex(): string {\n    return this.disabled ? '-1' : '0'\n  }\n\n  /** Returns the host DOM element. */\n  _getHostElement(): HTMLElement {\n    return this._elementRef.nativeElement\n  }\n\n  /** Prevents the default element actions if it is disabled. */\n  @HostListener('click', ['$event'])\n  _checkDisabled(event: Event): void {\n    if (this.disabled) {\n      event.preventDefault()\n      event.stopPropagation()\n    }\n  }\n\n  /** Emits to the hover stream. */\n  @HostListener('mouseenter')\n  _handleMouseEnter() {\n    this._hovered.next(this)\n  }\n\n  /** Gets the label to be used when determining whether the option should be focused. */\n  getLabel(): string {\n    const element: HTMLElement = this._elementRef.nativeElement\n    const textNodeType = this.document ? this.document.TEXT_NODE : 3\n    let output = ''\n\n    if (element.childNodes) {\n      const length = element.childNodes.length\n\n      // Go through all the top-level text nodes and extract their text.\n      // We skip anything that's not a text node to prevent the text from\n      // being thrown off by something like an icon.\n      for (let i = 0; i < length; i++) {\n        if (element.childNodes[i].nodeType === textNodeType) {\n          output += element.childNodes[i].textContent\n        }\n      }\n    }\n\n    return output.trim()\n  }\n\n}\n"]}

package/esm2015/menu/menu-panel-token.js

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token used to provide the parent menu to menu-specific components.
+ */
+export const THESEAM_MENU_PANEL = new InjectionToken('THESEAM_MENU_PANEL');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wYW5lbC10b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tZW51L21lbnUtcGFuZWwtdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUk5Qzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLElBQUksY0FBYyxDQUFvQixvQkFBb0IsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBJVGhlU2VhbU1lbnVQYW5lbCB9IGZyb20gJy4vbWVudS1wYW5lbCdcblxuLyoqXG4gKiBJbmplY3Rpb24gdG9rZW4gdXNlZCB0byBwcm92aWRlIHRoZSBwYXJlbnQgbWVudSB0byBtZW51LXNwZWNpZmljIGNvbXBvbmVudHMuXG4gKi9cbmV4cG9ydCBjb25zdCBUSEVTRUFNX01FTlVfUEFORUwgPSBuZXcgSW5qZWN0aW9uVG9rZW48SVRoZVNlYW1NZW51UGFuZWw+KCdUSEVTRUFNX01FTlVfUEFORUwnKVxuIl19

package/esm2015/menu/menu-panel.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wYW5lbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9tZW51L21lbnUtcGFuZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvY3VzT3JpZ2luIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknXG5pbXBvcnQgeyBEaXJlY3Rpb24gfSBmcm9tICdAYW5ndWxhci9jZGsvYmlkaSdcbmltcG9ydCB7IEV2ZW50RW1pdHRlciwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBNZW51Rm9vdGVyQ29tcG9uZW50IH0gZnJvbSAnLi9tZW51LWZvb3Rlci9tZW51LWZvb3Rlci5jb21wb25lbnQnXG5pbXBvcnQgeyBNZW51SGVhZGVyQ29tcG9uZW50IH0gZnJvbSAnLi9tZW51LWhlYWRlci9tZW51LWhlYWRlci5jb21wb25lbnQnXG5cbi8qKlxuICogSW50ZXJmYWNlIGZvciBhIGN1c3RvbSBtZW51IHBhbmVsIHRoYXQgY2FuIGJlIHVzZWQgd2l0aCBgc2VhbU1lbnVUb2dnbGVgLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIElUaGVTZWFtTWVudVBhbmVsPFQgPSBhbnk+IHtcbiAgdGVtcGxhdGVSZWY/OiBUZW1wbGF0ZVJlZjxhbnk+XG4gIGNsb3NlZDogRXZlbnRFbWl0dGVyPHZvaWQgfCAnY2xpY2snIHwgJ2tleWRvd24nIHwgJ3RhYic+XG4gIHBhcmVudE1lbnU/OiBJVGhlU2VhbU1lbnVQYW5lbCB8IHVuZGVmaW5lZFxuICBkaXJlY3Rpb24/OiBEaXJlY3Rpb25cbiAgZm9jdXNGaXJzdEl0ZW06IChvcmlnaW4/OiBGb2N1c09yaWdpbikgPT4gdm9pZFxuICByZXNldEFjdGl2ZUl0ZW06ICgpID0+IHZvaWRcbiAgYWRkSXRlbT86IChpdGVtOiBUKSA9PiB2b2lkXG4gIHJlbW92ZUl0ZW0/OiAoaXRlbTogVCkgPT4gdm9pZFxuICBzZXRGb290ZXI/OiAoZm9vdGVyPzogTWVudUZvb3RlckNvbXBvbmVudCkgPT4gdm9pZFxuICBzZXRIZWFkZXI/OiAoaGVhZGVyPzogTWVudUhlYWRlckNvbXBvbmVudCkgPT4gdm9pZFxufVxuIl19

package/esm2015/menu/menu-toggle.directive.js

@@ -0,0 +1,248 @@
+import { FocusMonitor, isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
+import { DOWN_ARROW, ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';
+import { Overlay } from '@angular/cdk/overlay';
+import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, HostListener, Input, ViewContainerRef } from '@angular/core';
+import { merge, of, Subscription } from 'rxjs';
+/** Options for binding a passive event listener. */
+const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
+export class MenuToggleDirective {
+    // @HostListener('document:mousedown', [ '$event' ])
+    // _onDocumentMouseDown(event: any) {
+    //   console.log('outside click')
+    // }
+    constructor(_elementRef, _viewContainerRef, _overlay, _focusMonitor) {
+        this._elementRef = _elementRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._overlay = _overlay;
+        this._focusMonitor = _focusMonitor;
+        this._active = false;
+        this._menuClosedSubscription = Subscription.EMPTY;
+        this._closingActionsSubscription = Subscription.EMPTY;
+        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
+        this._openedBy = null;
+        this._positions = [
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+        ];
+        /**
+         * 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._elementRef.nativeElement.addEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
+    }
+    set positions(val) {
+        var _a;
+        this._positions = val;
+        if (this.menuOpen()) {
+            (_a = this._overlayRef) === null || _a === void 0 ? void 0 : _a.updatePositionStrategy(this.getOverlayPosition(this._elementRef.nativeElement));
+        }
+    }
+    get positions() { return this._positions; }
+    _onMouseDown(event) {
+        if (!isFakeMousedownFromScreenReader(event)) {
+            // Since right or middle button clicks won't trigger the `click` event,
+            // we shouldn't consider the menu as opened by mouse in those cases.
+            this._openedBy = event.button === 0 ? 'mouse' : null;
+            // 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();
+            // }
+        }
+    }
+    _onKeydown(event) {
+        var _a;
+        this._openedBy = null;
+        // tslint:disable-next-line:deprecation
+        const keyCode = event.keyCode;
+        if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {
+            if (this.menuOpen()) {
+                (_a = this.seamMenuToggle) === null || _a === void 0 ? void 0 : _a.focusFirstItem(this._openedBy || 'program');
+            }
+        }
+    }
+    _onClick(event) {
+        this.toggle();
+    }
+    _onDocumentKeydown(event) {
+        if (event.keyCode === ESCAPE) {
+            this.closeMenu();
+        }
+    }
+    ngOnDestroy() {
+        this.closeMenu();
+        this._elementRef.nativeElement.removeEventListener('touchstart', this._handleTouchStart, passiveEventListenerOptions);
+        this._menuClosedSubscription.unsubscribe();
+        this._closingActionsSubscription.unsubscribe();
+    }
+    toggle() {
+        if (this._active) {
+            this.closeMenu();
+        }
+        else {
+            this.openMenu();
+        }
+    }
+    openMenu() {
+        if (this._active || !this.seamMenuToggle) {
+            return;
+        }
+        this._active = true;
+        this._overlayRef = this._overlay.create({
+            hasBackdrop: true,
+            backdropClass: 'transparent',
+            positionStrategy: this.getOverlayPosition(this._elementRef.nativeElement),
+        });
+        const tpl = this.seamMenuToggle.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 => {
+            // console.log('closed', v)
+            this.closeMenu();
+        });
+        // this._overlayRef.backdropClick().subscribe(v => {
+        //   console.log('backdropClick', v)
+        // })
+    }
+    closeMenu() {
+        var _a, _b;
+        if (!this._active) {
+            return;
+        }
+        if ((_a = this._overlayRef) === null || _a === void 0 ? void 0 : _a.hasAttached()) {
+            (_b = this._overlayRef) === null || _b === void 0 ? void 0 : _b.detach();
+        }
+        this._resetMenu();
+        this._menuClosedSubscription.unsubscribe();
+        this._closingActionsSubscription.unsubscribe();
+        this._active = false;
+    }
+    menuOpen() {
+        var _a;
+        return (_a = (this._overlayRef && this._overlayRef.hasAttached())) !== null && _a !== void 0 ? _a : false;
+    }
+    getOverlayPosition(origin) {
+        const positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(origin)
+            .withPositions(this.positions)
+            .withFlexibleDimensions(false)
+            .withPush(true);
+        return positionStrategy;
+    }
+    /**
+     * Focuses the menu trigger.
+     * @param origin Source of the menu trigger's focus.
+     */
+    focus(origin = 'program') {
+        if (this._focusMonitor) {
+            this._focusMonitor.focusVia(this._elementRef, origin);
+        }
+        else {
+            this._elementRef.nativeElement.focus();
+        }
+    }
+    /**
+     * 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')
+    }
+    /**
+     * 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)
+        // 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.
+        if (this.restoreFocus) {
+            if (!this._openedBy) {
+                // Note that the focus style will show up both for `program` and
+                // `keyboard` so we don't have to specify which one it is.
+                this.focus();
+            }
+            // else if (!this.triggersSubmenu()) {
+            //   this.focus(this._openedBy)
+            // }
+        }
+        this._openedBy = null;
+    }
+    /** Returns a stream that emits whenever an action that should close the menu occurs. */
+    _menuClosingActions() {
+        var _a, _b, _c, _d;
+        const backdrop = (_b = (_a = this._overlayRef) === null || _a === void 0 ? void 0 : _a.backdropClick()) !== null && _b !== void 0 ? _b : of();
+        const detachments = (_d = (_c = this._overlayRef) === null || _c === void 0 ? void 0 : _c.detachments()) !== null && _d !== void 0 ? _d : 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();
+        return merge(backdrop, parentClose, hover, detachments);
+    }
+}
+MenuToggleDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[seamMenuToggle]',
+                // tslint:disable-next-line:use-host-property-decorator
+                host: {
+                    'aria-haspopup': 'true',
+                    '[attr.aria-expanded]': 'menuOpen() || null'
+                },
+                exportAs: 'seamMenuToggle'
+            },] }
+];
+MenuToggleDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ViewContainerRef },
+    { type: Overlay },
+    { type: FocusMonitor }
+];
+MenuToggleDirective.propDecorators = {
+    seamMenuToggle: [{ type: Input }],
+    positions: [{ type: Input }],
+    _onMouseDown: [{ type: HostListener, args: ['mousedown', ['$event'],] }],
+    _onKeydown: [{ type: HostListener, args: ['keydown', ['$event'],] }],
+    _onClick: [{ type: HostListener, args: ['click', ['$event'],] }],
+    _onDocumentKeydown: [{ 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._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"]}