@angular/cdk
Version:
Angular Material Component Development Kit
162 lines • 13.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/cdk/overlay/keyboard/overlay-keyboard-dispatcher.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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 {
/**
* @param {?} document
*/
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 = (/**
* @param {?} event
* @return {?}
*/
(event) => {
/** @type {?} */
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]._keydownEventSubscriptions > 0) {
overlays[i]._keydownEvents.next(event);
break;
}
}
});
this._document = document;
}
/**
* @return {?}
*/
ngOnDestroy() {
this._detach();
}
/**
* Add a new overlay to the list of attached overlay refs.
* @param {?} overlayRef
* @return {?}
*/
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.
* @param {?} overlayRef
* @return {?}
*/
remove(overlayRef) {
/** @type {?} */
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.
* @private
* @return {?}
*/
_detach() {
if (this._isAttached) {
this._document.body.removeEventListener('keydown', this._keydownListener);
this._isAttached = false;
}
}
}
OverlayKeyboardDispatcher.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] }
];
/** @nocollapse */
OverlayKeyboardDispatcher.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
/** @nocollapse */ OverlayKeyboardDispatcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(i0.ɵɵinject(i1.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
if (false) {
/**
* Currently attached overlays in the order they were attached.
* @type {?}
*/
OverlayKeyboardDispatcher.prototype._attachedOverlays;
/**
* @type {?}
* @private
*/
OverlayKeyboardDispatcher.prototype._document;
/**
* @type {?}
* @private
*/
OverlayKeyboardDispatcher.prototype._isAttached;
/**
* Keyboard event listener that will be attached to the body.
* @type {?}
* @private
*/
OverlayKeyboardDispatcher.prototype._keydownListener;
}
/**
* \@docs-private \@deprecated \@breaking-change 8.0.0
* @param {?} dispatcher
* @param {?} _document
* @return {?}
*/
export function OVERLAY_KEYBOARD_DISPATCHER_PROVIDER_FACTORY(dispatcher, _document) {
return dispatcher || new OverlayKeyboardDispatcher(_document);
}
/**
* \@docs-private \@deprecated \@breaking-change 8.0.0
* @type {?}
*/
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],
(/** @type {?} */ (
// 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 {OverlayRef} from '../overlay-ref';\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: OverlayRef[] = [];\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: OverlayRef): 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: OverlayRef): 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]._keydownEventSubscriptions > 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"]}