@angular/cdk
Version:
Angular Material Component Development Kit
96 lines • 12.6 kB
JavaScript
/**
* @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 { DOCUMENT } from '@angular/common';
import { Inject, Injectable, Optional, SkipSelf, } from '@angular/core';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common";
/**
* Service for dispatching keyboard events that land on the body to appropriate overlay ref,
* if any. It maintains a list of attached overlays to determine best suited overlay based
* on event target and order of overlay opens.
*/
export class OverlayKeyboardDispatcher {
constructor(document) {
/** Currently attached overlays in the order they were attached. */
this._attachedOverlays = [];
/** Keyboard event listener that will be attached to the body. */
this._keydownListener = (event) => {
const overlays = this._attachedOverlays;
for (let i = overlays.length - 1; i > -1; i--) {
// Dispatch the keydown event to the top overlay which has subscribers to its keydown events.
// We want to target the most recent overlay, rather than trying to match where the event came
// from, because some components might open an overlay, but keep focus on a trigger element
// (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,
// because we don't want overlays that don't handle keyboard events to block the ones below
// them that do.
if (overlays[i]._keydownEvents.observers.length > 0) {
overlays[i]._keydownEvents.next(event);
break;
}
}
};
this._document = document;
}
ngOnDestroy() {
this._detach();
}
/** Add a new overlay to the list of attached overlay refs. */
add(overlayRef) {
// Ensure that we don't get the same overlay multiple times.
this.remove(overlayRef);
// Lazily start dispatcher once first overlay is added
if (!this._isAttached) {
this._document.body.addEventListener('keydown', this._keydownListener);
this._isAttached = true;
}
this._attachedOverlays.push(overlayRef);
}
/** Remove an overlay from the list of attached overlay refs. */
remove(overlayRef) {
const index = this._attachedOverlays.indexOf(overlayRef);
if (index > -1) {
this._attachedOverlays.splice(index, 1);
}
// Remove the global listener once there are no more overlays.
if (this._attachedOverlays.length === 0) {
this._detach();
}
}
/** Detaches the global keyboard event listener. */
_detach() {
if (this._isAttached) {
this._document.body.removeEventListener('keydown', this._keydownListener);
this._isAttached = false;
}
}
}
OverlayKeyboardDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(i0.ɵɵinject(i1.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
OverlayKeyboardDispatcher.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] }
];
OverlayKeyboardDispatcher.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
/** @docs-private @deprecated @breaking-change 8.0.0 */
export function OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY(dispatcher, _document) {
return dispatcher || new OverlayKeyboardDispatcher(_document);
}
/** @docs-private @deprecated @breaking-change 8.0.0 */
export const OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {
// If there is already an OverlayKeyboardDispatcher available, use that.
// Otherwise, provide a new one.
provide: OverlayKeyboardDispatcher,
deps: [
[new Optional(), new SkipSelf(), OverlayKeyboardDispatcher],
// Coerce to `InjectionToken` so that the `deps` match the "shape"
// of the type expected by Angular
DOCUMENT
],
useFactory: OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-keyboard-dispatcher.js","sourceRoot":"","sources":["../../../../../../../src/cdk/overlay/keyboard/overlay-keyboard-dispatcher.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 {DOCUMENT} from '@angular/common';\nimport {\n  Inject,\n  Injectable,\n  InjectionToken,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n} from '@angular/core';\nimport {OverlayReference} from '../overlay-reference';\n\n\n/**\n * Service for dispatching keyboard events that land on the body to appropriate overlay ref,\n * if any. It maintains a list of attached overlays to determine best suited overlay based\n * on event target and order of overlay opens.\n */\n@Injectable({providedIn: 'root'})\nexport class OverlayKeyboardDispatcher implements OnDestroy {\n\n  /** Currently attached overlays in the order they were attached. */\n  _attachedOverlays: OverlayReference[] = [];\n\n  private _document: Document;\n  private _isAttached: boolean;\n\n  constructor(@Inject(DOCUMENT) document: any) {\n    this._document = document;\n  }\n\n  ngOnDestroy() {\n    this._detach();\n  }\n\n  /** Add a new overlay to the list of attached overlay refs. */\n  add(overlayRef: OverlayReference): void {\n    // Ensure that we don't get the same overlay multiple times.\n    this.remove(overlayRef);\n\n    // Lazily start dispatcher once first overlay is added\n    if (!this._isAttached) {\n      this._document.body.addEventListener('keydown', this._keydownListener);\n      this._isAttached = true;\n    }\n\n    this._attachedOverlays.push(overlayRef);\n  }\n\n  /** Remove an overlay from the list of attached overlay refs. */\n  remove(overlayRef: OverlayReference): void {\n    const index = this._attachedOverlays.indexOf(overlayRef);\n\n    if (index > -1) {\n      this._attachedOverlays.splice(index, 1);\n    }\n\n    // Remove the global listener once there are no more overlays.\n    if (this._attachedOverlays.length === 0) {\n      this._detach();\n    }\n  }\n\n  /** Detaches the global keyboard event listener. */\n  private _detach() {\n    if (this._isAttached) {\n      this._document.body.removeEventListener('keydown', this._keydownListener);\n      this._isAttached = false;\n    }\n  }\n\n  /** Keyboard event listener that will be attached to the body. */\n  private _keydownListener = (event: KeyboardEvent) => {\n    const overlays = this._attachedOverlays;\n\n    for (let i = overlays.length - 1; i > -1; i--) {\n      // Dispatch the keydown event to the top overlay which has subscribers to its keydown events.\n      // We want to target the most recent overlay, rather than trying to match where the event came\n      // from, because some components might open an overlay, but keep focus on a trigger element\n      // (e.g. for select and autocomplete). We skip overlays without keydown event subscriptions,\n      // because we don't want overlays that don't handle keyboard events to block the ones below\n      // them that do.\n      if (overlays[i]._keydownEvents.observers.length > 0) {\n        overlays[i]._keydownEvents.next(event);\n        break;\n      }\n    }\n  }\n}\n\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport function OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY(\n    dispatcher: OverlayKeyboardDispatcher, _document: any) {\n  return dispatcher || new OverlayKeyboardDispatcher(_document);\n}\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport const OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {\n  // If there is already an OverlayKeyboardDispatcher available, use that.\n  // Otherwise, provide a new one.\n  provide: OverlayKeyboardDispatcher,\n  deps: [\n    [new Optional(), new SkipSelf(), OverlayKeyboardDispatcher],\n\n    // Coerce to `InjectionToken` so that the `deps` match the \"shape\"\n    // of the type expected by Angular\n    DOCUMENT as InjectionToken<any>\n  ],\n  useFactory: OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY\n};\n"]}