/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Directive } from '@angular/core';
import { DOWN_ARROW, ESCAPE, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, TAB, UP_ARROW, } from '@angular/cdk/keycodes';
import { takeUntil } from 'rxjs/operators';
import { CdkMenuGroup } from './menu-group';
import { CDK_MENU } from './menu-interface';
import { MENU_STACK, MenuStack } from './menu-stack';
import { CdkMenuBase } from './menu-base';
import * as i0 from "@angular/core";
/**
 * Directive applied to an element which configures it as a MenuBar by setting the appropriate
 * role, aria attributes, and accessible keyboard and mouse handling logic. The component that
 * this directive is applied to should contain components marked with CdkMenuItem.
 *
 */
export class CdkMenuBar extends CdkMenuBase {
    constructor() {
        super(...arguments);
        /** The direction items in the menu flow. */
        this.orientation = 'horizontal';
        /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
        this.isInline = true;
    }
    ngAfterContentInit() {
        super.ngAfterContentInit();
        this._subscribeToMenuStackEmptied();
    }
    /**
     * Handle keyboard events for the Menu.
     * @param event The keyboard event to be handled.
     */
    _handleKeyEvent(event) {
        const keyManager = this.keyManager;
        switch (event.keyCode) {
            case UP_ARROW:
            case DOWN_ARROW:
            case LEFT_ARROW:
            case RIGHT_ARROW:
                if (!hasModifierKey(event)) {
                    const horizontalArrows = event.keyCode === LEFT_ARROW || event.keyCode === RIGHT_ARROW;
                    // For a horizontal menu if the left/right keys were clicked, or a vertical menu if the
                    // up/down keys were clicked: if the current menu is open, close it then focus and open the
                    // next  menu.
                    if (horizontalArrows) {
                        event.preventDefault();
                        const prevIsOpen = keyManager.activeItem?.isMenuOpen();
                        keyManager.activeItem?.getMenuTrigger()?.close();
                        keyManager.setFocusOrigin('keyboard');
                        keyManager.onKeydown(event);
                        if (prevIsOpen) {
                            keyManager.activeItem?.getMenuTrigger()?.open();
                        }
                    }
                }
                break;
            case ESCAPE:
                if (!hasModifierKey(event)) {
                    event.preventDefault();
                    keyManager.activeItem?.getMenuTrigger()?.close();
                }
                break;
            case TAB:
                if (!hasModifierKey(event, 'altKey', 'metaKey', 'ctrlKey')) {
                    keyManager.activeItem?.getMenuTrigger()?.close();
                }
                break;
            default:
                keyManager.onKeydown(event);
        }
    }
    /**
     * Set focus to either the current, previous or next item based on the FocusNext event, then
     * open the previous or next item.
     * @param focusNext The element to focus.
     */
    _toggleOpenMenu(focusNext) {
        const keyManager = this.keyManager;
        switch (focusNext) {
            case 0 /* FocusNext.nextItem */:
                keyManager.setFocusOrigin('keyboard');
                keyManager.setNextItemActive();
                keyManager.activeItem?.getMenuTrigger()?.open();
                break;
            case 1 /* FocusNext.previousItem */:
                keyManager.setFocusOrigin('keyboard');
                keyManager.setPreviousItemActive();
                keyManager.activeItem?.getMenuTrigger()?.open();
                break;
            case 2 /* FocusNext.currentItem */:
                if (keyManager.activeItem) {
                    keyManager.setFocusOrigin('keyboard');
                    keyManager.setActiveItem(keyManager.activeItem);
                }
                break;
        }
    }
    /** Subscribe to the MenuStack emptied events. */
    _subscribeToMenuStackEmptied() {
        this.menuStack?.emptied
            .pipe(takeUntil(this.destroyed))
            .subscribe(event => this._toggleOpenMenu(event));
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: CdkMenuBar, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.1", type: CdkMenuBar, isStandalone: true, selector: "[cdkMenuBar]", host: { attributes: { "role": "menubar" }, listeners: { "keydown": "_handleKeyEvent($event)" }, classAttribute: "cdk-menu-bar" }, providers: [
            { provide: CdkMenuGroup, useExisting: CdkMenuBar },
            { provide: CDK_MENU, useExisting: CdkMenuBar },
            { provide: MENU_STACK, useFactory: () => MenuStack.inline('horizontal') },
        ], exportAs: ["cdkMenuBar"], usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: CdkMenuBar, decorators: [{
            type: Directive,
            args: [{
                    selector: '[cdkMenuBar]',
                    exportAs: 'cdkMenuBar',
                    standalone: true,
                    host: {
                        'role': 'menubar',
                        'class': 'cdk-menu-bar',
                        '(keydown)': '_handleKeyEvent($event)',
                    },
                    providers: [
                        { provide: CdkMenuGroup, useExisting: CdkMenuBar },
                        { provide: CDK_MENU, useExisting: CdkMenuBar },
                        { provide: MENU_STACK, useFactory: () => MenuStack.inline('horizontal') },
                    ],
                }]
        }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-bar.js","sourceRoot":"","sources":["../../../../../../src/cdk/menu/menu-bar.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {AfterContentInit, Directive} from '@angular/core';\nimport {\n  DOWN_ARROW,\n  ESCAPE,\n  hasModifierKey,\n  LEFT_ARROW,\n  RIGHT_ARROW,\n  TAB,\n  UP_ARROW,\n} from '@angular/cdk/keycodes';\nimport {takeUntil} from 'rxjs/operators';\nimport {CdkMenuGroup} from './menu-group';\nimport {CDK_MENU} from './menu-interface';\nimport {FocusNext, MENU_STACK, MenuStack} from './menu-stack';\nimport {CdkMenuBase} from './menu-base';\n\n/**\n * Directive applied to an element which configures it as a MenuBar by setting the appropriate\n * role, aria attributes, and accessible keyboard and mouse handling logic. The component that\n * this directive is applied to should contain components marked with CdkMenuItem.\n *\n */\n@Directive({\n  selector: '[cdkMenuBar]',\n  exportAs: 'cdkMenuBar',\n  standalone: true,\n  host: {\n    'role': 'menubar',\n    'class': 'cdk-menu-bar',\n    '(keydown)': '_handleKeyEvent($event)',\n  },\n  providers: [\n    {provide: CdkMenuGroup, useExisting: CdkMenuBar},\n    {provide: CDK_MENU, useExisting: CdkMenuBar},\n    {provide: MENU_STACK, useFactory: () => MenuStack.inline('horizontal')},\n  ],\n})\nexport class CdkMenuBar extends CdkMenuBase implements AfterContentInit {\n  /** The direction items in the menu flow. */\n  override readonly orientation = 'horizontal';\n\n  /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */\n  override readonly isInline = true;\n\n  override ngAfterContentInit() {\n    super.ngAfterContentInit();\n    this._subscribeToMenuStackEmptied();\n  }\n\n  /**\n   * Handle keyboard events for the Menu.\n   * @param event The keyboard event to be handled.\n   */\n  _handleKeyEvent(event: KeyboardEvent) {\n    const keyManager = this.keyManager;\n    switch (event.keyCode) {\n      case UP_ARROW:\n      case DOWN_ARROW:\n      case LEFT_ARROW:\n      case RIGHT_ARROW:\n        if (!hasModifierKey(event)) {\n          const horizontalArrows = event.keyCode === LEFT_ARROW || event.keyCode === RIGHT_ARROW;\n          // For a horizontal menu if the left/right keys were clicked, or a vertical menu if the\n          // up/down keys were clicked: if the current menu is open, close it then focus and open the\n          // next  menu.\n          if (horizontalArrows) {\n            event.preventDefault();\n\n            const prevIsOpen = keyManager.activeItem?.isMenuOpen();\n            keyManager.activeItem?.getMenuTrigger()?.close();\n\n            keyManager.setFocusOrigin('keyboard');\n            keyManager.onKeydown(event);\n            if (prevIsOpen) {\n              keyManager.activeItem?.getMenuTrigger()?.open();\n            }\n          }\n        }\n        break;\n\n      case ESCAPE:\n        if (!hasModifierKey(event)) {\n          event.preventDefault();\n          keyManager.activeItem?.getMenuTrigger()?.close();\n        }\n        break;\n\n      case TAB:\n        if (!hasModifierKey(event, 'altKey', 'metaKey', 'ctrlKey')) {\n          keyManager.activeItem?.getMenuTrigger()?.close();\n        }\n        break;\n\n      default:\n        keyManager.onKeydown(event);\n    }\n  }\n\n  /**\n   * Set focus to either the current, previous or next item based on the FocusNext event, then\n   * open the previous or next item.\n   * @param focusNext The element to focus.\n   */\n  private _toggleOpenMenu(focusNext: FocusNext | undefined) {\n    const keyManager = this.keyManager;\n    switch (focusNext) {\n      case FocusNext.nextItem:\n        keyManager.setFocusOrigin('keyboard');\n        keyManager.setNextItemActive();\n        keyManager.activeItem?.getMenuTrigger()?.open();\n        break;\n\n      case FocusNext.previousItem:\n        keyManager.setFocusOrigin('keyboard');\n        keyManager.setPreviousItemActive();\n        keyManager.activeItem?.getMenuTrigger()?.open();\n        break;\n\n      case FocusNext.currentItem:\n        if (keyManager.activeItem) {\n          keyManager.setFocusOrigin('keyboard');\n          keyManager.setActiveItem(keyManager.activeItem);\n        }\n        break;\n    }\n  }\n\n  /** Subscribe to the MenuStack emptied events. */\n  private _subscribeToMenuStackEmptied() {\n    this.menuStack?.emptied\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(event => this._toggleOpenMenu(event));\n  }\n}\n"]}