@angular/cdk 14.0.0-next.10 → 14.0.0-next.13

package/esm2020/menu/menu-aim.mjs

@@ -0,0 +1,204 @@
+/**
+ * @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 { Injectable, NgZone, InjectionToken, Directive } from '@angular/core';
+import { fromEvent, Subject } from 'rxjs';
+import { takeUntil, filter } from 'rxjs/operators';
+import { throwMissingPointerFocusTracker, throwMissingMenuReference } from './menu-errors';
+import * as i0 from "@angular/core";
+/** Injection token used for an implementation of MenuAim. */
+export const MENU_AIM = new InjectionToken('cdk-menu-aim');
+/** Capture every nth mouse move event. */
+const MOUSE_MOVE_SAMPLE_FREQUENCY = 3;
+/** The number of mouse move events to track. */
+const NUM_POINTS = 5;
+/**
+ * How long to wait before closing a sibling menu if a user stops short of the submenu they were
+ * predicted to go into.
+ */
+const CLOSE_DELAY = 300;
+/** Calculate the slope between point a and b. */
+function getSlope(a, b) {
+    return (b.y - a.y) / (b.x - a.x);
+}
+/** Calculate the y intercept for the given point and slope. */
+function getYIntercept(point, slope) {
+    return point.y - slope * point.x;
+}
+/**
+ * Whether the given mouse trajectory line defined by the slope and y intercept falls within the
+ * submenu as defined by `submenuPoints`
+ * @param submenuPoints the submenu DOMRect points.
+ * @param m the slope of the trajectory line.
+ * @param b the y intercept of the trajectory line.
+ * @return true if any point on the line falls within the submenu.
+ */
+function isWithinSubmenu(submenuPoints, m, b) {
+    const { left, right, top, bottom } = submenuPoints;
+    // Check for intersection with each edge of the submenu (left, right, top, bottom)
+    // by fixing one coordinate to that edge's coordinate (either x or y) and checking if the
+    // other coordinate is within bounds.
+    return ((m * left + b >= top && m * left + b <= bottom) ||
+        (m * right + b >= top && m * right + b <= bottom) ||
+        ((top - b) / m >= left && (top - b) / m <= right) ||
+        ((bottom - b) / m >= left && (bottom - b) / m <= right));
+}
+/**
+ * TargetMenuAim predicts if a user is moving into a submenu. It calculates the
+ * trajectory of the user's mouse movement in the current menu to determine if the
+ * mouse is moving towards an open submenu.
+ *
+ * The determination is made by calculating the slope of the users last NUM_POINTS moves where each
+ * pair of points determines if the trajectory line points into the submenu. It uses consensus
+ * approach by checking if at least NUM_POINTS / 2 pairs determine that the user is moving towards
+ * to submenu.
+ */
+export class TargetMenuAim {
+    constructor(
+    /** The Angular zone. */
+    _ngZone) {
+        this._ngZone = _ngZone;
+        /** The last NUM_POINTS mouse move events. */
+        this._points = [];
+        /** Emits when this service is destroyed. */
+        this._destroyed = new Subject();
+    }
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /**
+     * Set the Menu and its PointerFocusTracker.
+     * @param menu The menu that this menu aim service controls.
+     * @param pointerTracker The `PointerFocusTracker` for the given menu.
+     */
+    initialize(menu, pointerTracker) {
+        this._menu = menu;
+        this._pointerTracker = pointerTracker;
+        this._subscribeToMouseMoves();
+    }
+    /**
+     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
+     * the submenu.
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    toggle(doToggle) {
+        // If the menu is horizontal the sub-menus open below and there is no risk of premature
+        // closing of any sub-menus therefore we automatically resolve the callback.
+        if (this._menu.orientation === 'horizontal') {
+            doToggle();
+        }
+        this._checkConfigured();
+        const siblingItemIsWaiting = !!this._timeoutId;
+        const hasPoints = this._points.length > 1;
+        if (hasPoints && !siblingItemIsWaiting) {
+            if (this._isMovingToSubmenu()) {
+                this._startTimeout(doToggle);
+            }
+            else {
+                doToggle();
+            }
+        }
+        else if (!siblingItemIsWaiting) {
+            doToggle();
+        }
+    }
+    /**
+     * Start the delayed toggle handler if one isn't running already.
+     *
+     * The delayed toggle handler executes the `doToggle` callback after some period of time iff the
+     * users mouse is on an item in the current menu.
+     *
+     * @param doToggle the function called when the user is not moving towards the submenu.
+     */
+    _startTimeout(doToggle) {
+        // If the users mouse is moving towards a submenu we don't want to immediately resolve.
+        // Wait for some period of time before determining if the previous menu should close in
+        // cases where the user may have moved towards the submenu but stopped on a sibling menu
+        // item intentionally.
+        const timeoutId = setTimeout(() => {
+            // Resolve if the user is currently moused over some element in the root menu
+            if (this._pointerTracker.activeElement && timeoutId === this._timeoutId) {
+                doToggle();
+            }
+            this._timeoutId = null;
+        }, CLOSE_DELAY);
+        this._timeoutId = timeoutId;
+    }
+    /** Whether the user is heading towards the open submenu. */
+    _isMovingToSubmenu() {
+        const submenuPoints = this._getSubmenuBounds();
+        if (!submenuPoints) {
+            return false;
+        }
+        let numMoving = 0;
+        const currPoint = this._points[this._points.length - 1];
+        // start from the second last point and calculate the slope between each point and the last
+        // point.
+        for (let i = this._points.length - 2; i >= 0; i--) {
+            const previous = this._points[i];
+            const slope = getSlope(currPoint, previous);
+            if (isWithinSubmenu(submenuPoints, slope, getYIntercept(currPoint, slope))) {
+                numMoving++;
+            }
+        }
+        return numMoving >= Math.floor(NUM_POINTS / 2);
+    }
+    /** Get the bounding DOMRect for the open submenu. */
+    _getSubmenuBounds() {
+        return this._pointerTracker?.previousElement?.getMenu()?.nativeElement.getBoundingClientRect();
+    }
+    /**
+     * Check if a reference to the PointerFocusTracker and menu element is provided.
+     * @throws an error if neither reference is provided.
+     */
+    _checkConfigured() {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (!this._pointerTracker) {
+                throwMissingPointerFocusTracker();
+            }
+            if (!this._menu) {
+                throwMissingMenuReference();
+            }
+        }
+    }
+    /** Subscribe to the root menus mouse move events and update the tracked mouse points. */
+    _subscribeToMouseMoves() {
+        this._ngZone.runOutsideAngular(() => {
+            fromEvent(this._menu.nativeElement, 'mousemove')
+                .pipe(filter((_, index) => index % MOUSE_MOVE_SAMPLE_FREQUENCY === 0), takeUntil(this._destroyed))
+                .subscribe((event) => {
+                this._points.push({ x: event.clientX, y: event.clientY });
+                if (this._points.length > NUM_POINTS) {
+                    this._points.shift();
+                }
+            });
+        });
+    }
+}
+TargetMenuAim.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.15", ngImport: i0, type: TargetMenuAim, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+TargetMenuAim.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.0-next.15", ngImport: i0, type: TargetMenuAim });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.15", ngImport: i0, type: TargetMenuAim, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+/**
+ * CdkTargetMenuAim is a provider for the TargetMenuAim service. It can be added to an
+ * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
+ */
+export class CdkTargetMenuAim {
+}
+CdkTargetMenuAim.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.15", ngImport: i0, type: CdkTargetMenuAim, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkTargetMenuAim.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.15", type: CdkTargetMenuAim, selector: "[cdkTargetMenuAim]", providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }], exportAs: ["cdkTargetMenuAim"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-next.15", ngImport: i0, type: CdkTargetMenuAim, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkTargetMenuAim]',
+                    exportAs: 'cdkTargetMenuAim',
+                    providers: [{ provide: MENU_AIM, useClass: TargetMenuAim }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-aim.js","sourceRoot":"","sources":["../../../../../../src/cdk/menu/menu-aim.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,UAAU,EAAE,MAAM,EAAa,cAAc,EAAE,SAAS,EAAC,MAAM,eAAe,CAAC;AACvF,OAAO,EAAC,SAAS,EAAE,OAAO,EAAC,MAAM,MAAM,CAAC;AACxC,OAAO,EAAC,SAAS,EAAE,MAAM,EAAC,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAAC,+BAA+B,EAAE,yBAAyB,EAAC,MAAM,eAAe,CAAC;;AAuBzF,6DAA6D;AAC7D,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,cAAc,CAAU,cAAc,CAAC,CAAC;AAEpE,0CAA0C;AAC1C,MAAM,2BAA2B,GAAG,CAAC,CAAC;AAEtC,gDAAgD;AAChD,MAAM,UAAU,GAAG,CAAC,CAAC;AAErB;;;GAGG;AACH,MAAM,WAAW,GAAG,GAAG,CAAC;AAQxB,iDAAiD;AACjD,SAAS,QAAQ,CAAC,CAAQ,EAAE,CAAQ;IAClC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnC,CAAC;AAED,+DAA+D;AAC/D,SAAS,aAAa,CAAC,KAAY,EAAE,KAAa;IAChD,OAAO,KAAK,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;AACnC,CAAC;AAKD;;;;;;;GAOG;AACH,SAAS,eAAe,CAAC,aAAsB,EAAE,CAAS,EAAE,CAAS;IACnE,MAAM,EAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAC,GAAG,aAAa,CAAC;IAEjD,kFAAkF;IAClF,yFAAyF;IACzF,qCAAqC;IACrC,OAAO,CACL,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,MAAM,CAAC;QAC/C,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,IAAI,MAAM,CAAC;QACjD,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC;QACjD,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,CACxD,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AAEH,MAAM,OAAO,aAAa;IAgBxB;IACE,wBAAwB;IACP,OAAe;QAAf,YAAO,GAAP,OAAO,CAAQ;QAjBlC,6CAA6C;QAC5B,YAAO,GAAY,EAAE,CAAC;QAWvC,4CAA4C;QAC3B,eAAU,GAAkB,IAAI,OAAO,EAAE,CAAC;IAKxD,CAAC;IAEJ,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,IAAU,EAAE,cAA+D;QACpF,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,QAAoB;QACzB,uFAAuF;QACvF,4EAA4E;QAC5E,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,KAAK,YAAY,EAAE;YAC3C,QAAQ,EAAE,CAAC;SACZ;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QAE1C,IAAI,SAAS,IAAI,CAAC,oBAAoB,EAAE;YACtC,IAAI,IAAI,CAAC,kBAAkB,EAAE,EAAE;gBAC7B,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;aAC9B;iBAAM;gBACL,QAAQ,EAAE,CAAC;aACZ;SACF;aAAM,IAAI,CAAC,oBAAoB,EAAE;YAChC,QAAQ,EAAE,CAAC;SACZ;IACH,CAAC;IAED;;;;;;;OAOG;IACK,aAAa,CAAC,QAAoB;QACxC,uFAAuF;QACvF,uFAAuF;QACvF,wFAAwF;QACxF,sBAAsB;QACtB,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAChC,6EAA6E;YAC7E,IAAI,IAAI,CAAC,eAAgB,CAAC,aAAa,IAAI,SAAS,KAAK,IAAI,CAAC,UAAU,EAAE;gBACxE,QAAQ,EAAE,CAAC;aACZ;YACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACzB,CAAC,EAAE,WAAW,CAAkB,CAAC;QAEjC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,4DAA4D;IACpD,kBAAkB;QACxB,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC/C,IAAI,CAAC,aAAa,EAAE;YAClB,OAAO,KAAK,CAAC;SACd;QAED,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACxD,2FAA2F;QAC3F,SAAS;QACT,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACjC,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC5C,IAAI,eAAe,CAAC,aAAa,EAAE,KAAK,EAAE,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,EAAE;gBAC1E,SAAS,EAAE,CAAC;aACb;SACF;QACD,OAAO,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,qDAAqD;IAC7C,iBAAiB;QACvB,OAAO,IAAI,CAAC,eAAe,EAAE,eAAe,EAAE,OAAO,EAAE,EAAE,aAAa,CAAC,qBAAqB,EAAE,CAAC;IACjG,CAAC;IAED;;;OAGG;IACK,gBAAgB;QACtB,IAAI,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,EAAE;YACjD,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;gBACzB,+BAA+B,EAAE,CAAC;aACnC;YACD,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;gBACf,yBAAyB,EAAE,CAAC;aAC7B;SACF;IACH,CAAC;IAED,yFAAyF;IACjF,sBAAsB;QAC5B,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAClC,SAAS,CAAa,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,WAAW,CAAC;iBACzD,IAAI,CACH,MAAM,CAAC,CAAC,CAAa,EAAE,KAAa,EAAE,EAAE,CAAC,KAAK,GAAG,2BAA2B,KAAK,CAAC,CAAC,EACnF,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;iBACA,SAAS,CAAC,CAAC,KAAiB,EAAE,EAAE;gBAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAC,CAAC,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,OAAO,EAAC,CAAC,CAAC;gBACxD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,UAAU,EAAE;oBACpC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;iBACtB;YACH,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;;kHAjJU,aAAa;sHAAb,aAAa;mGAAb,aAAa;kBADzB,UAAU;;AAqJX;;;GAGG;AAMH,MAAM,OAAO,gBAAgB;;qHAAhB,gBAAgB;yGAAhB,gBAAgB,6CAFhB,CAAC,EAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAC,CAAC;mGAE9C,gBAAgB;kBAL5B,SAAS;mBAAC;oBACT,QAAQ,EAAE,oBAAoB;oBAC9B,QAAQ,EAAE,kBAAkB;oBAC5B,SAAS,EAAE,CAAC,EAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAC,CAAC;iBAC1D","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 {Injectable, NgZone, OnDestroy, InjectionToken, Directive} from '@angular/core';\nimport {fromEvent, Subject} from 'rxjs';\nimport {takeUntil, filter} from 'rxjs/operators';\nimport {PointerFocusTracker, FocusableElement} from './pointer-focus-tracker';\nimport {Menu} from './menu-interface';\nimport {throwMissingPointerFocusTracker, throwMissingMenuReference} from './menu-errors';\n\n/**\n * MenuAim is responsible for determining if a sibling menuitem's menu should be closed when a\n * Toggler item is hovered into. It is up to the hovered in item to call the MenuAim service in\n * order to determine if it may perform its close actions.\n */\nexport interface MenuAim {\n  /**\n   * Set the Menu and its PointerFocusTracker.\n   * @param menu The menu that this menu aim service controls.\n   * @param pointerTracker The `PointerFocusTracker` for the given menu.\n   */\n  initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;\n\n  /**\n   * Calls the `doToggle` callback when it is deemed that the user is not moving towards\n   * the submenu.\n   * @param doToggle the function called when the user is not moving towards the submenu.\n   */\n  toggle(doToggle: () => void): void;\n}\n\n/** Injection token used for an implementation of MenuAim. */\nexport const MENU_AIM = new InjectionToken<MenuAim>('cdk-menu-aim');\n\n/** Capture every nth mouse move event. */\nconst MOUSE_MOVE_SAMPLE_FREQUENCY = 3;\n\n/** The number of mouse move events to track. */\nconst NUM_POINTS = 5;\n\n/**\n * How long to wait before closing a sibling menu if a user stops short of the submenu they were\n * predicted to go into.\n */\nconst CLOSE_DELAY = 300;\n\n/** An element which when hovered over may open or close a menu. */\nexport interface Toggler {\n  /** Gets the open menu, or undefined if no menu is open. */\n  getMenu(): Menu | undefined;\n}\n\n/** Calculate the slope between point a and b. */\nfunction getSlope(a: Point, b: Point) {\n  return (b.y - a.y) / (b.x - a.x);\n}\n\n/** Calculate the y intercept for the given point and slope. */\nfunction getYIntercept(point: Point, slope: number) {\n  return point.y - slope * point.x;\n}\n\n/** Represents a coordinate of mouse travel. */\ntype Point = {x: number; y: number};\n\n/**\n * Whether the given mouse trajectory line defined by the slope and y intercept falls within the\n * submenu as defined by `submenuPoints`\n * @param submenuPoints the submenu DOMRect points.\n * @param m the slope of the trajectory line.\n * @param b the y intercept of the trajectory line.\n * @return true if any point on the line falls within the submenu.\n */\nfunction isWithinSubmenu(submenuPoints: DOMRect, m: number, b: number) {\n  const {left, right, top, bottom} = submenuPoints;\n\n  // Check for intersection with each edge of the submenu (left, right, top, bottom)\n  // by fixing one coordinate to that edge's coordinate (either x or y) and checking if the\n  // other coordinate is within bounds.\n  return (\n    (m * left + b >= top && m * left + b <= bottom) ||\n    (m * right + b >= top && m * right + b <= bottom) ||\n    ((top - b) / m >= left && (top - b) / m <= right) ||\n    ((bottom - b) / m >= left && (bottom - b) / m <= right)\n  );\n}\n\n/**\n * TargetMenuAim predicts if a user is moving into a submenu. It calculates the\n * trajectory of the user's mouse movement in the current menu to determine if the\n * mouse is moving towards an open submenu.\n *\n * The determination is made by calculating the slope of the users last NUM_POINTS moves where each\n * pair of points determines if the trajectory line points into the submenu. It uses consensus\n * approach by checking if at least NUM_POINTS / 2 pairs determine that the user is moving towards\n * to submenu.\n */\n@Injectable()\nexport class TargetMenuAim implements MenuAim, OnDestroy {\n  /** The last NUM_POINTS mouse move events. */\n  private readonly _points: Point[] = [];\n\n  /** Reference to the root menu in which we are tracking mouse moves. */\n  private _menu: Menu;\n\n  /** Reference to the root menu's mouse manager. */\n  private _pointerTracker: PointerFocusTracker<Toggler & FocusableElement>;\n\n  /** The id associated with the current timeout call waiting to resolve. */\n  private _timeoutId: number | null;\n\n  /** Emits when this service is destroyed. */\n  private readonly _destroyed: Subject<void> = new Subject();\n\n  constructor(\n    /** The Angular zone. */\n    private readonly _ngZone: NgZone,\n  ) {}\n\n  ngOnDestroy() {\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /**\n   * Set the Menu and its PointerFocusTracker.\n   * @param menu The menu that this menu aim service controls.\n   * @param pointerTracker The `PointerFocusTracker` for the given menu.\n   */\n  initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>) {\n    this._menu = menu;\n    this._pointerTracker = pointerTracker;\n    this._subscribeToMouseMoves();\n  }\n\n  /**\n   * Calls the `doToggle` callback when it is deemed that the user is not moving towards\n   * the submenu.\n   * @param doToggle the function called when the user is not moving towards the submenu.\n   */\n  toggle(doToggle: () => void) {\n    // If the menu is horizontal the sub-menus open below and there is no risk of premature\n    // closing of any sub-menus therefore we automatically resolve the callback.\n    if (this._menu.orientation === 'horizontal') {\n      doToggle();\n    }\n\n    this._checkConfigured();\n\n    const siblingItemIsWaiting = !!this._timeoutId;\n    const hasPoints = this._points.length > 1;\n\n    if (hasPoints && !siblingItemIsWaiting) {\n      if (this._isMovingToSubmenu()) {\n        this._startTimeout(doToggle);\n      } else {\n        doToggle();\n      }\n    } else if (!siblingItemIsWaiting) {\n      doToggle();\n    }\n  }\n\n  /**\n   * Start the delayed toggle handler if one isn't running already.\n   *\n   * The delayed toggle handler executes the `doToggle` callback after some period of time iff the\n   * users mouse is on an item in the current menu.\n   *\n   * @param doToggle the function called when the user is not moving towards the submenu.\n   */\n  private _startTimeout(doToggle: () => void) {\n    // If the users mouse is moving towards a submenu we don't want to immediately resolve.\n    // Wait for some period of time before determining if the previous menu should close in\n    // cases where the user may have moved towards the submenu but stopped on a sibling menu\n    // item intentionally.\n    const timeoutId = setTimeout(() => {\n      // Resolve if the user is currently moused over some element in the root menu\n      if (this._pointerTracker!.activeElement && timeoutId === this._timeoutId) {\n        doToggle();\n      }\n      this._timeoutId = null;\n    }, CLOSE_DELAY) as any as number;\n\n    this._timeoutId = timeoutId;\n  }\n\n  /** Whether the user is heading towards the open submenu. */\n  private _isMovingToSubmenu() {\n    const submenuPoints = this._getSubmenuBounds();\n    if (!submenuPoints) {\n      return false;\n    }\n\n    let numMoving = 0;\n    const currPoint = this._points[this._points.length - 1];\n    // start from the second last point and calculate the slope between each point and the last\n    // point.\n    for (let i = this._points.length - 2; i >= 0; i--) {\n      const previous = this._points[i];\n      const slope = getSlope(currPoint, previous);\n      if (isWithinSubmenu(submenuPoints, slope, getYIntercept(currPoint, slope))) {\n        numMoving++;\n      }\n    }\n    return numMoving >= Math.floor(NUM_POINTS / 2);\n  }\n\n  /** Get the bounding DOMRect for the open submenu. */\n  private _getSubmenuBounds(): DOMRect | undefined {\n    return this._pointerTracker?.previousElement?.getMenu()?.nativeElement.getBoundingClientRect();\n  }\n\n  /**\n   * Check if a reference to the PointerFocusTracker and menu element is provided.\n   * @throws an error if neither reference is provided.\n   */\n  private _checkConfigured() {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      if (!this._pointerTracker) {\n        throwMissingPointerFocusTracker();\n      }\n      if (!this._menu) {\n        throwMissingMenuReference();\n      }\n    }\n  }\n\n  /** Subscribe to the root menus mouse move events and update the tracked mouse points. */\n  private _subscribeToMouseMoves() {\n    this._ngZone.runOutsideAngular(() => {\n      fromEvent<MouseEvent>(this._menu.nativeElement, 'mousemove')\n        .pipe(\n          filter((_: MouseEvent, index: number) => index % MOUSE_MOVE_SAMPLE_FREQUENCY === 0),\n          takeUntil(this._destroyed),\n        )\n        .subscribe((event: MouseEvent) => {\n          this._points.push({x: event.clientX, y: event.clientY});\n          if (this._points.length > NUM_POINTS) {\n            this._points.shift();\n          }\n        });\n    });\n  }\n}\n\n/**\n * CdkTargetMenuAim is a provider for the TargetMenuAim service. It can be added to an\n * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.\n */\n@Directive({\n  selector: '[cdkTargetMenuAim]',\n  exportAs: 'cdkTargetMenuAim',\n  providers: [{provide: MENU_AIM, useClass: TargetMenuAim}],\n})\nexport class CdkTargetMenuAim {}\n"]}

package/esm2020/menu/menu-bar.mjs

@@ -0,0 +1,159 @@
+/**
+ * @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, ElementRef, Inject, NgZone, Optional, Self, } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+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 { MENU_AIM } from './menu-aim';
+import { CdkMenuBase } from './menu-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "./menu-stack";
+/**
+ * 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(
+    /** The host element. */
+    elementRef, 
+    /** The Angular zone. */
+    ngZone, 
+    /** The menu stack this menu is part of. */
+    menuStack, 
+    /** The menu aim service used by this menu. */
+    menuAim, 
+    /** The directionality of the page. */
+    dir) {
+        super(elementRef, ngZone, menuStack, menuAim, dir);
+        /** 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 /* nextItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setNextItemActive();
+                keyManager.activeItem?.getMenuTrigger()?.open();
+                break;
+            case 1 /* previousItem */:
+                keyManager.setFocusOrigin('keyboard');
+                keyManager.setPreviousItemActive();
+                keyManager.activeItem?.getMenuTrigger()?.open();
+                break;
+            case 2 /* 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));
+    }
+}
+CdkMenuBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-next.15", ngImport: i0, type: CdkMenuBar, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: MENU_STACK }, { token: MENU_AIM, optional: true, self: true }, { token: i1.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+CdkMenuBar.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "14.0.0-next.15", type: CdkMenuBar, 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: "14.0.0-next.15", ngImport: i0, type: CdkMenuBar, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkMenuBar]',
+                    exportAs: 'cdkMenuBar',
+                    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') },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i2.MenuStack, decorators: [{
+                    type: Inject,
+                    args: [MENU_STACK]
+                }] }, { type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MENU_AIM]
+                }] }, { type: i1.Directionality, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# 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 {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  Inject,\n  NgZone,\n  Optional,\n  Self,\n} from '@angular/core';\nimport {Directionality} from '@angular/cdk/bidi';\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 {MENU_AIM, MenuAim} from './menu-aim';\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  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  constructor(\n    /** The host element. */\n    elementRef: ElementRef<HTMLElement>,\n    /** The Angular zone. */\n    ngZone: NgZone,\n    /** The menu stack this menu is part of. */\n    @Inject(MENU_STACK) menuStack: MenuStack,\n    /** The menu aim service used by this menu. */\n    @Self() @Optional() @Inject(MENU_AIM) menuAim?: MenuAim,\n    /** The directionality of the page. */\n    @Optional() dir?: Directionality,\n  ) {\n    super(elementRef, ngZone, menuStack, menuAim, dir);\n  }\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"]}