You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
414 lines
54 KiB
414 lines
54 KiB
/**
|
|
* @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 { coerceBooleanProperty } from '@angular/cdk/coercion';
|
|
import { _getFocusedElementPierceShadowDom } from '@angular/cdk/platform';
|
|
import { DOCUMENT } from '@angular/common';
|
|
import { Directive, ElementRef, Inject, Injectable, Input, NgZone, } from '@angular/core';
|
|
import { take } from 'rxjs/operators';
|
|
import { InteractivityChecker } from '../interactivity-checker/interactivity-checker';
|
|
import * as i0 from "@angular/core";
|
|
import * as i1 from "../interactivity-checker/interactivity-checker";
|
|
import * as i2 from "@angular/common";
|
|
/**
|
|
* Class that allows for trapping focus within a DOM element.
|
|
*
|
|
* This class currently uses a relatively simple approach to focus trapping.
|
|
* It assumes that the tab order is the same as DOM order, which is not necessarily true.
|
|
* Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.
|
|
*
|
|
* @deprecated Use `ConfigurableFocusTrap` instead.
|
|
* @breaking-change 11.0.0
|
|
*/
|
|
import * as ɵngcc0 from '@angular/core';
|
|
import * as ɵngcc1 from '../interactivity-checker/interactivity-checker';
|
|
export class FocusTrap {
|
|
constructor(_element, _checker, _ngZone, _document, deferAnchors = false) {
|
|
this._element = _element;
|
|
this._checker = _checker;
|
|
this._ngZone = _ngZone;
|
|
this._document = _document;
|
|
this._hasAttached = false;
|
|
// Event listeners for the anchors. Need to be regular functions so that we can unbind them later.
|
|
this.startAnchorListener = () => this.focusLastTabbableElement();
|
|
this.endAnchorListener = () => this.focusFirstTabbableElement();
|
|
this._enabled = true;
|
|
if (!deferAnchors) {
|
|
this.attachAnchors();
|
|
}
|
|
}
|
|
/** Whether the focus trap is active. */
|
|
get enabled() { return this._enabled; }
|
|
set enabled(value) {
|
|
this._enabled = value;
|
|
if (this._startAnchor && this._endAnchor) {
|
|
this._toggleAnchorTabIndex(value, this._startAnchor);
|
|
this._toggleAnchorTabIndex(value, this._endAnchor);
|
|
}
|
|
}
|
|
/** Destroys the focus trap by cleaning up the anchors. */
|
|
destroy() {
|
|
const startAnchor = this._startAnchor;
|
|
const endAnchor = this._endAnchor;
|
|
if (startAnchor) {
|
|
startAnchor.removeEventListener('focus', this.startAnchorListener);
|
|
if (startAnchor.parentNode) {
|
|
startAnchor.parentNode.removeChild(startAnchor);
|
|
}
|
|
}
|
|
if (endAnchor) {
|
|
endAnchor.removeEventListener('focus', this.endAnchorListener);
|
|
if (endAnchor.parentNode) {
|
|
endAnchor.parentNode.removeChild(endAnchor);
|
|
}
|
|
}
|
|
this._startAnchor = this._endAnchor = null;
|
|
this._hasAttached = false;
|
|
}
|
|
/**
|
|
* Inserts the anchors into the DOM. This is usually done automatically
|
|
* in the constructor, but can be deferred for cases like directives with `*ngIf`.
|
|
* @returns Whether the focus trap managed to attach successfully. This may not be the case
|
|
* if the target element isn't currently in the DOM.
|
|
*/
|
|
attachAnchors() {
|
|
// If we're not on the browser, there can be no focus to trap.
|
|
if (this._hasAttached) {
|
|
return true;
|
|
}
|
|
this._ngZone.runOutsideAngular(() => {
|
|
if (!this._startAnchor) {
|
|
this._startAnchor = this._createAnchor();
|
|
this._startAnchor.addEventListener('focus', this.startAnchorListener);
|
|
}
|
|
if (!this._endAnchor) {
|
|
this._endAnchor = this._createAnchor();
|
|
this._endAnchor.addEventListener('focus', this.endAnchorListener);
|
|
}
|
|
});
|
|
if (this._element.parentNode) {
|
|
this._element.parentNode.insertBefore(this._startAnchor, this._element);
|
|
this._element.parentNode.insertBefore(this._endAnchor, this._element.nextSibling);
|
|
this._hasAttached = true;
|
|
}
|
|
return this._hasAttached;
|
|
}
|
|
/**
|
|
* Waits for the zone to stabilize, then either focuses the first element that the
|
|
* user specified, or the first tabbable element.
|
|
* @returns Returns a promise that resolves with a boolean, depending
|
|
* on whether focus was moved successfully.
|
|
*/
|
|
focusInitialElementWhenReady(options) {
|
|
return new Promise(resolve => {
|
|
this._executeOnStable(() => resolve(this.focusInitialElement(options)));
|
|
});
|
|
}
|
|
/**
|
|
* Waits for the zone to stabilize, then focuses
|
|
* the first tabbable element within the focus trap region.
|
|
* @returns Returns a promise that resolves with a boolean, depending
|
|
* on whether focus was moved successfully.
|
|
*/
|
|
focusFirstTabbableElementWhenReady(options) {
|
|
return new Promise(resolve => {
|
|
this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));
|
|
});
|
|
}
|
|
/**
|
|
* Waits for the zone to stabilize, then focuses
|
|
* the last tabbable element within the focus trap region.
|
|
* @returns Returns a promise that resolves with a boolean, depending
|
|
* on whether focus was moved successfully.
|
|
*/
|
|
focusLastTabbableElementWhenReady(options) {
|
|
return new Promise(resolve => {
|
|
this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));
|
|
});
|
|
}
|
|
/**
|
|
* Get the specified boundary element of the trapped region.
|
|
* @param bound The boundary to get (start or end of trapped region).
|
|
* @returns The boundary element.
|
|
*/
|
|
_getRegionBoundary(bound) {
|
|
// Contains the deprecated version of selector, for temporary backwards comparability.
|
|
let markers = this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` +
|
|
`[cdkFocusRegion${bound}], ` +
|
|
`[cdk-focus-${bound}]`);
|
|
for (let i = 0; i < markers.length; i++) {
|
|
// @breaking-change 8.0.0
|
|
if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {
|
|
console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` +
|
|
`use 'cdkFocusRegion${bound}' instead. The deprecated ` +
|
|
`attribute will be removed in 8.0.0.`, markers[i]);
|
|
}
|
|
else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {
|
|
console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +
|
|
`use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +
|
|
`will be removed in 8.0.0.`, markers[i]);
|
|
}
|
|
}
|
|
if (bound == 'start') {
|
|
return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);
|
|
}
|
|
return markers.length ?
|
|
markers[markers.length - 1] : this._getLastTabbableElement(this._element);
|
|
}
|
|
/**
|
|
* Focuses the element that should be focused when the focus trap is initialized.
|
|
* @returns Whether focus was moved successfully.
|
|
*/
|
|
focusInitialElement(options) {
|
|
// Contains the deprecated version of selector, for temporary backwards comparability.
|
|
const redirectToElement = this._element.querySelector(`[cdk-focus-initial], ` +
|
|
`[cdkFocusInitial]`);
|
|
if (redirectToElement) {
|
|
// @breaking-change 8.0.0
|
|
if (redirectToElement.hasAttribute(`cdk-focus-initial`)) {
|
|
console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` +
|
|
`use 'cdkFocusInitial' instead. The deprecated attribute ` +
|
|
`will be removed in 8.0.0`, redirectToElement);
|
|
}
|
|
// Warn the consumer if the element they've pointed to
|
|
// isn't focusable, when not in production mode.
|
|
if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
|
|
!this._checker.isFocusable(redirectToElement)) {
|
|
console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);
|
|
}
|
|
if (!this._checker.isFocusable(redirectToElement)) {
|
|
const focusableChild = this._getFirstTabbableElement(redirectToElement);
|
|
focusableChild === null || focusableChild === void 0 ? void 0 : focusableChild.focus(options);
|
|
return !!focusableChild;
|
|
}
|
|
redirectToElement.focus(options);
|
|
return true;
|
|
}
|
|
return this.focusFirstTabbableElement(options);
|
|
}
|
|
/**
|
|
* Focuses the first tabbable element within the focus trap region.
|
|
* @returns Whether focus was moved successfully.
|
|
*/
|
|
focusFirstTabbableElement(options) {
|
|
const redirectToElement = this._getRegionBoundary('start');
|
|
if (redirectToElement) {
|
|
redirectToElement.focus(options);
|
|
}
|
|
return !!redirectToElement;
|
|
}
|
|
/**
|
|
* Focuses the last tabbable element within the focus trap region.
|
|
* @returns Whether focus was moved successfully.
|
|
*/
|
|
focusLastTabbableElement(options) {
|
|
const redirectToElement = this._getRegionBoundary('end');
|
|
if (redirectToElement) {
|
|
redirectToElement.focus(options);
|
|
}
|
|
return !!redirectToElement;
|
|
}
|
|
/**
|
|
* Checks whether the focus trap has successfully been attached.
|
|
*/
|
|
hasAttached() {
|
|
return this._hasAttached;
|
|
}
|
|
/** Get the first tabbable element from a DOM subtree (inclusive). */
|
|
_getFirstTabbableElement(root) {
|
|
if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
|
|
return root;
|
|
}
|
|
// Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall
|
|
// back to `childNodes` which includes text nodes, comments etc.
|
|
let children = root.children || root.childNodes;
|
|
for (let i = 0; i < children.length; i++) {
|
|
let tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?
|
|
this._getFirstTabbableElement(children[i]) :
|
|
null;
|
|
if (tabbableChild) {
|
|
return tabbableChild;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
/** Get the last tabbable element from a DOM subtree (inclusive). */
|
|
_getLastTabbableElement(root) {
|
|
if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
|
|
return root;
|
|
}
|
|
// Iterate in reverse DOM order.
|
|
let children = root.children || root.childNodes;
|
|
for (let i = children.length - 1; i >= 0; i--) {
|
|
let tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?
|
|
this._getLastTabbableElement(children[i]) :
|
|
null;
|
|
if (tabbableChild) {
|
|
return tabbableChild;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
/** Creates an anchor element. */
|
|
_createAnchor() {
|
|
const anchor = this._document.createElement('div');
|
|
this._toggleAnchorTabIndex(this._enabled, anchor);
|
|
anchor.classList.add('cdk-visually-hidden');
|
|
anchor.classList.add('cdk-focus-trap-anchor');
|
|
anchor.setAttribute('aria-hidden', 'true');
|
|
return anchor;
|
|
}
|
|
/**
|
|
* Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.
|
|
* @param isEnabled Whether the focus trap is enabled.
|
|
* @param anchor Anchor on which to toggle the tabindex.
|
|
*/
|
|
_toggleAnchorTabIndex(isEnabled, anchor) {
|
|
// Remove the tabindex completely, rather than setting it to -1, because if the
|
|
// element has a tabindex, the user might still hit it when navigating with the arrow keys.
|
|
isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');
|
|
}
|
|
/**
|
|
* Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.
|
|
* @param enabled: Whether the anchors should trap Tab.
|
|
*/
|
|
toggleAnchors(enabled) {
|
|
if (this._startAnchor && this._endAnchor) {
|
|
this._toggleAnchorTabIndex(enabled, this._startAnchor);
|
|
this._toggleAnchorTabIndex(enabled, this._endAnchor);
|
|
}
|
|
}
|
|
/** Executes a function when the zone is stable. */
|
|
_executeOnStable(fn) {
|
|
if (this._ngZone.isStable) {
|
|
fn();
|
|
}
|
|
else {
|
|
this._ngZone.onStable.pipe(take(1)).subscribe(fn);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Factory that allows easy instantiation of focus traps.
|
|
* @deprecated Use `ConfigurableFocusTrapFactory` instead.
|
|
* @breaking-change 11.0.0
|
|
*/
|
|
export class FocusTrapFactory {
|
|
constructor(_checker, _ngZone, _document) {
|
|
this._checker = _checker;
|
|
this._ngZone = _ngZone;
|
|
this._document = _document;
|
|
}
|
|
/**
|
|
* Creates a focus-trapped region around the given element.
|
|
* @param element The element around which focus will be trapped.
|
|
* @param deferCaptureElements Defers the creation of focus-capturing elements to be done
|
|
* manually by the user.
|
|
* @returns The created focus trap instance.
|
|
*/
|
|
create(element, deferCaptureElements = false) {
|
|
return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);
|
|
}
|
|
}
|
|
FocusTrapFactory.ɵfac = function FocusTrapFactory_Factory(t) { return new (t || FocusTrapFactory)(ɵngcc0.ɵɵinject(ɵngcc1.InteractivityChecker), ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT)); };
|
|
FocusTrapFactory.ɵprov = i0.ɵɵdefineInjectable({ factory: function FocusTrapFactory_Factory() { return new FocusTrapFactory(i0.ɵɵinject(i1.InteractivityChecker), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i2.DOCUMENT)); }, token: FocusTrapFactory, providedIn: "root" });
|
|
FocusTrapFactory.ctorParameters = () => [
|
|
{ type: InteractivityChecker },
|
|
{ type: NgZone },
|
|
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
|
|
];
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(FocusTrapFactory, [{
|
|
type: Injectable,
|
|
args: [{ providedIn: 'root' }]
|
|
}], function () { return [{ type: ɵngcc1.InteractivityChecker }, { type: ɵngcc0.NgZone }, { type: undefined, decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}] }]; }, null); })();
|
|
/** Directive for trapping focus within a region. */
|
|
export class CdkTrapFocus {
|
|
constructor(_elementRef, _focusTrapFactory,
|
|
/**
|
|
* @deprecated No longer being used. To be removed.
|
|
* @breaking-change 13.0.0
|
|
*/
|
|
_document) {
|
|
this._elementRef = _elementRef;
|
|
this._focusTrapFactory = _focusTrapFactory;
|
|
/** Previously focused element to restore focus to upon destroy when using autoCapture. */
|
|
this._previouslyFocusedElement = null;
|
|
this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
|
|
}
|
|
/** Whether the focus trap is active. */
|
|
get enabled() { return this.focusTrap.enabled; }
|
|
set enabled(value) { this.focusTrap.enabled = coerceBooleanProperty(value); }
|
|
/**
|
|
* Whether the directive should automatically move focus into the trapped region upon
|
|
* initialization and return focus to the previous activeElement upon destruction.
|
|
*/
|
|
get autoCapture() { return this._autoCapture; }
|
|
set autoCapture(value) { this._autoCapture = coerceBooleanProperty(value); }
|
|
ngOnDestroy() {
|
|
this.focusTrap.destroy();
|
|
// If we stored a previously focused element when using autoCapture, return focus to that
|
|
// element now that the trapped region is being destroyed.
|
|
if (this._previouslyFocusedElement) {
|
|
this._previouslyFocusedElement.focus();
|
|
this._previouslyFocusedElement = null;
|
|
}
|
|
}
|
|
ngAfterContentInit() {
|
|
this.focusTrap.attachAnchors();
|
|
if (this.autoCapture) {
|
|
this._captureFocus();
|
|
}
|
|
}
|
|
ngDoCheck() {
|
|
if (!this.focusTrap.hasAttached()) {
|
|
this.focusTrap.attachAnchors();
|
|
}
|
|
}
|
|
ngOnChanges(changes) {
|
|
const autoCaptureChange = changes['autoCapture'];
|
|
if (autoCaptureChange && !autoCaptureChange.firstChange && this.autoCapture &&
|
|
this.focusTrap.hasAttached()) {
|
|
this._captureFocus();
|
|
}
|
|
}
|
|
_captureFocus() {
|
|
this._previouslyFocusedElement = _getFocusedElementPierceShadowDom();
|
|
this.focusTrap.focusInitialElementWhenReady();
|
|
}
|
|
}
|
|
CdkTrapFocus.ɵfac = function CdkTrapFocus_Factory(t) { return new (t || CdkTrapFocus)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(FocusTrapFactory), ɵngcc0.ɵɵdirectiveInject(DOCUMENT)); };
|
|
CdkTrapFocus.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkTrapFocus, selectors: [["", "cdkTrapFocus", ""]], inputs: { enabled: ["cdkTrapFocus", "enabled"], autoCapture: ["cdkTrapFocusAutoCapture", "autoCapture"] }, exportAs: ["cdkTrapFocus"], features: [ɵngcc0.ɵɵNgOnChangesFeature] });
|
|
CdkTrapFocus.ctorParameters = () => [
|
|
{ type: ElementRef },
|
|
{ type: FocusTrapFactory },
|
|
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
|
|
];
|
|
CdkTrapFocus.propDecorators = {
|
|
enabled: [{ type: Input, args: ['cdkTrapFocus',] }],
|
|
autoCapture: [{ type: Input, args: ['cdkTrapFocusAutoCapture',] }]
|
|
};
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkTrapFocus, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: '[cdkTrapFocus]',
|
|
exportAs: 'cdkTrapFocus'
|
|
}]
|
|
}], function () { return [{ type: ɵngcc0.ElementRef }, { type: FocusTrapFactory }, { type: undefined, decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}] }]; }, { enabled: [{
|
|
type: Input,
|
|
args: ['cdkTrapFocus']
|
|
}], autoCapture: [{
|
|
type: Input,
|
|
args: ['cdkTrapFocusAutoCapture']
|
|
}] }); })();
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"focus-trap.js","sources":["../../../../../../../src/cdk/a11y/focus-trap/focus-trap.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 {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {_getFocusedElementPierceShadowDom} from '@angular/cdk/platform';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  Inject,\n  Injectable,\n  Input,\n  NgZone,\n  OnDestroy,\n  DoCheck,\n  SimpleChanges,\n  OnChanges,\n} from '@angular/core';\nimport {take} from 'rxjs/operators';\nimport {InteractivityChecker} from '../interactivity-checker/interactivity-checker';\n\n\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * This class currently uses a relatively simple approach to focus trapping.\n * It assumes that the tab order is the same as DOM order, which is not necessarily true.\n * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.\n *\n * @deprecated Use `ConfigurableFocusTrap` instead.\n * @breaking-change 11.0.0\n */\nexport class FocusTrap {\n  private _startAnchor: HTMLElement | null;\n  private _endAnchor: HTMLElement | null;\n  private _hasAttached = false;\n\n  // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.\n  protected startAnchorListener = () => this.focusLastTabbableElement();\n  protected endAnchorListener = () => this.focusFirstTabbableElement();\n\n  /** Whether the focus trap is active. */\n  get enabled(): boolean { return this._enabled; }\n  set enabled(value: boolean) {\n    this._enabled = value;\n\n    if (this._startAnchor && this._endAnchor) {\n      this._toggleAnchorTabIndex(value, this._startAnchor);\n      this._toggleAnchorTabIndex(value, this._endAnchor);\n    }\n  }\n  protected _enabled: boolean = true;\n\n  constructor(\n    readonly _element: HTMLElement,\n    private _checker: InteractivityChecker,\n    readonly _ngZone: NgZone,\n    readonly _document: Document,\n    deferAnchors = false) {\n\n    if (!deferAnchors) {\n      this.attachAnchors();\n    }\n  }\n\n  /** Destroys the focus trap by cleaning up the anchors. */\n  destroy() {\n    const startAnchor = this._startAnchor;\n    const endAnchor = this._endAnchor;\n\n    if (startAnchor) {\n      startAnchor.removeEventListener('focus', this.startAnchorListener);\n\n      if (startAnchor.parentNode) {\n        startAnchor.parentNode.removeChild(startAnchor);\n      }\n    }\n\n    if (endAnchor) {\n      endAnchor.removeEventListener('focus', this.endAnchorListener);\n\n      if (endAnchor.parentNode) {\n        endAnchor.parentNode.removeChild(endAnchor);\n      }\n    }\n\n    this._startAnchor = this._endAnchor = null;\n    this._hasAttached = false;\n  }\n\n  /**\n   * Inserts the anchors into the DOM. This is usually done automatically\n   * in the constructor, but can be deferred for cases like directives with `*ngIf`.\n   * @returns Whether the focus trap managed to attach successfully. This may not be the case\n   * if the target element isn't currently in the DOM.\n   */\n  attachAnchors(): boolean {\n    // If we're not on the browser, there can be no focus to trap.\n    if (this._hasAttached) {\n      return true;\n    }\n\n    this._ngZone.runOutsideAngular(() => {\n      if (!this._startAnchor) {\n        this._startAnchor = this._createAnchor();\n        this._startAnchor!.addEventListener('focus', this.startAnchorListener);\n      }\n\n      if (!this._endAnchor) {\n        this._endAnchor = this._createAnchor();\n        this._endAnchor!.addEventListener('focus', this.endAnchorListener);\n      }\n    });\n\n    if (this._element.parentNode) {\n      this._element.parentNode.insertBefore(this._startAnchor!, this._element);\n      this._element.parentNode.insertBefore(this._endAnchor!, this._element.nextSibling);\n      this._hasAttached = true;\n    }\n\n    return this._hasAttached;\n  }\n\n  /**\n   * Waits for the zone to stabilize, then either focuses the first element that the\n   * user specified, or the first tabbable element.\n   * @returns Returns a promise that resolves with a boolean, depending\n   * on whether focus was moved successfully.\n   */\n  focusInitialElementWhenReady(options?: FocusOptions): Promise<boolean> {\n    return new Promise<boolean>(resolve => {\n      this._executeOnStable(() => resolve(this.focusInitialElement(options)));\n    });\n  }\n\n  /**\n   * Waits for the zone to stabilize, then focuses\n   * the first tabbable element within the focus trap region.\n   * @returns Returns a promise that resolves with a boolean, depending\n   * on whether focus was moved successfully.\n   */\n  focusFirstTabbableElementWhenReady(options?: FocusOptions): Promise<boolean> {\n    return new Promise<boolean>(resolve => {\n      this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));\n    });\n  }\n\n  /**\n   * Waits for the zone to stabilize, then focuses\n   * the last tabbable element within the focus trap region.\n   * @returns Returns a promise that resolves with a boolean, depending\n   * on whether focus was moved successfully.\n   */\n  focusLastTabbableElementWhenReady(options?: FocusOptions): Promise<boolean> {\n    return new Promise<boolean>(resolve => {\n      this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));\n    });\n  }\n\n  /**\n   * Get the specified boundary element of the trapped region.\n   * @param bound The boundary to get (start or end of trapped region).\n   * @returns The boundary element.\n   */\n  private _getRegionBoundary(bound: 'start' | 'end'): HTMLElement | null {\n    // Contains the deprecated version of selector, for temporary backwards comparability.\n    let markers = this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` +\n                                                 `[cdkFocusRegion${bound}], ` +\n                                                 `[cdk-focus-${bound}]`) as NodeListOf<HTMLElement>;\n\n    for (let i = 0; i < markers.length; i++) {\n      // @breaking-change 8.0.0\n      if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {\n        console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` +\n                     `use 'cdkFocusRegion${bound}' instead. The deprecated ` +\n                     `attribute will be removed in 8.0.0.`, markers[i]);\n      } else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {\n        console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +\n                     `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +\n                     `will be removed in 8.0.0.`, markers[i]);\n      }\n    }\n\n    if (bound == 'start') {\n      return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);\n    }\n    return markers.length ?\n        markers[markers.length - 1] : this._getLastTabbableElement(this._element);\n  }\n\n  /**\n   * Focuses the element that should be focused when the focus trap is initialized.\n   * @returns Whether focus was moved successfully.\n   */\n  focusInitialElement(options?: FocusOptions): boolean {\n    // Contains the deprecated version of selector, for temporary backwards comparability.\n    const redirectToElement = this._element.querySelector(`[cdk-focus-initial], ` +\n                                                          `[cdkFocusInitial]`) as HTMLElement;\n\n    if (redirectToElement) {\n      // @breaking-change 8.0.0\n      if (redirectToElement.hasAttribute(`cdk-focus-initial`)) {\n        console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` +\n                    `use 'cdkFocusInitial' instead. The deprecated attribute ` +\n                    `will be removed in 8.0.0`, redirectToElement);\n      }\n\n      // Warn the consumer if the element they've pointed to\n      // isn't focusable, when not in production mode.\n      if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n        !this._checker.isFocusable(redirectToElement)) {\n        console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);\n      }\n\n      if (!this._checker.isFocusable(redirectToElement)) {\n        const focusableChild = this._getFirstTabbableElement(redirectToElement) as HTMLElement;\n        focusableChild?.focus(options);\n        return !!focusableChild;\n      }\n\n      redirectToElement.focus(options);\n      return true;\n    }\n\n    return this.focusFirstTabbableElement(options);\n  }\n\n  /**\n   * Focuses the first tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  focusFirstTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getRegionBoundary('start');\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Focuses the last tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  focusLastTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getRegionBoundary('end');\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Checks whether the focus trap has successfully been attached.\n   */\n  hasAttached(): boolean {\n    return this._hasAttached;\n  }\n\n  /** Get the first tabbable element from a DOM subtree (inclusive). */\n  private _getFirstTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n      return root;\n    }\n\n    // Iterate in DOM order. Note that IE doesn't have `children` for SVG so we fall\n    // back to `childNodes` which includes text nodes, comments etc.\n    let children = root.children || root.childNodes;\n\n    for (let i = 0; i < children.length; i++) {\n      let tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?\n        this._getFirstTabbableElement(children[i] as HTMLElement) :\n        null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Get the last tabbable element from a DOM subtree (inclusive). */\n  private _getLastTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n      return root;\n    }\n\n    // Iterate in reverse DOM order.\n    let children = root.children || root.childNodes;\n\n    for (let i = children.length - 1; i >= 0; i--) {\n      let tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?\n        this._getLastTabbableElement(children[i] as HTMLElement) :\n        null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Creates an anchor element. */\n  private _createAnchor(): HTMLElement {\n    const anchor = this._document.createElement('div');\n    this._toggleAnchorTabIndex(this._enabled, anchor);\n    anchor.classList.add('cdk-visually-hidden');\n    anchor.classList.add('cdk-focus-trap-anchor');\n    anchor.setAttribute('aria-hidden', 'true');\n    return anchor;\n  }\n\n  /**\n   * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.\n   * @param isEnabled Whether the focus trap is enabled.\n   * @param anchor Anchor on which to toggle the tabindex.\n   */\n  private _toggleAnchorTabIndex(isEnabled: boolean, anchor: HTMLElement) {\n    // Remove the tabindex completely, rather than setting it to -1, because if the\n    // element has a tabindex, the user might still hit it when navigating with the arrow keys.\n    isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');\n  }\n\n  /**\n   * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.\n   * @param enabled: Whether the anchors should trap Tab.\n   */\n  protected toggleAnchors(enabled: boolean) {\n    if (this._startAnchor && this._endAnchor) {\n      this._toggleAnchorTabIndex(enabled, this._startAnchor);\n      this._toggleAnchorTabIndex(enabled, this._endAnchor);\n    }\n  }\n\n  /** Executes a function when the zone is stable. */\n  private _executeOnStable(fn: () => any): void {\n    if (this._ngZone.isStable) {\n      fn();\n    } else {\n      this._ngZone.onStable.pipe(take(1)).subscribe(fn);\n    }\n  }\n}\n\n/**\n * Factory that allows easy instantiation of focus traps.\n * @deprecated Use `ConfigurableFocusTrapFactory` instead.\n * @breaking-change 11.0.0\n */\n@Injectable({providedIn: 'root'})\nexport class FocusTrapFactory {\n  private _document: Document;\n\n  constructor(\n      private _checker: InteractivityChecker,\n      private _ngZone: NgZone,\n      @Inject(DOCUMENT) _document: any) {\n\n    this._document = _document;\n  }\n\n  /**\n   * Creates a focus-trapped region around the given element.\n   * @param element The element around which focus will be trapped.\n   * @param deferCaptureElements Defers the creation of focus-capturing elements to be done\n   *     manually by the user.\n   * @returns The created focus trap instance.\n   */\n  create(element: HTMLElement, deferCaptureElements: boolean = false): FocusTrap {\n    return new FocusTrap(\n        element, this._checker, this._ngZone, this._document, deferCaptureElements);\n  }\n}\n\n/** Directive for trapping focus within a region. */\n@Directive({\n  selector: '[cdkTrapFocus]',\n  exportAs: 'cdkTrapFocus',\n})\nexport class CdkTrapFocus implements OnDestroy, AfterContentInit, OnChanges, DoCheck {\n  /** Underlying FocusTrap instance. */\n  focusTrap: FocusTrap;\n\n  /** Previously focused element to restore focus to upon destroy when using autoCapture. */\n  private _previouslyFocusedElement: HTMLElement | null = null;\n\n  /** Whether the focus trap is active. */\n  @Input('cdkTrapFocus')\n  get enabled(): boolean { return this.focusTrap.enabled; }\n  set enabled(value: boolean) { this.focusTrap.enabled = coerceBooleanProperty(value); }\n\n  /**\n   * Whether the directive should automatically move focus into the trapped region upon\n   * initialization and return focus to the previous activeElement upon destruction.\n   */\n  @Input('cdkTrapFocusAutoCapture')\n  get autoCapture(): boolean { return this._autoCapture; }\n  set autoCapture(value: boolean) { this._autoCapture = coerceBooleanProperty(value); }\n  private _autoCapture: boolean;\n\n  constructor(\n      private _elementRef: ElementRef<HTMLElement>,\n      private _focusTrapFactory: FocusTrapFactory,\n      /**\n       * @deprecated No longer being used. To be removed.\n       * @breaking-change 13.0.0\n       */\n      @Inject(DOCUMENT) _document: any) {\n    this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n  }\n\n  ngOnDestroy() {\n    this.focusTrap.destroy();\n\n    // If we stored a previously focused element when using autoCapture, return focus to that\n    // element now that the trapped region is being destroyed.\n    if (this._previouslyFocusedElement) {\n      this._previouslyFocusedElement.focus();\n      this._previouslyFocusedElement = null;\n    }\n  }\n\n  ngAfterContentInit() {\n    this.focusTrap.attachAnchors();\n\n    if (this.autoCapture) {\n      this._captureFocus();\n    }\n  }\n\n  ngDoCheck() {\n    if (!this.focusTrap.hasAttached()) {\n      this.focusTrap.attachAnchors();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    const autoCaptureChange = changes['autoCapture'];\n\n    if (autoCaptureChange && !autoCaptureChange.firstChange && this.autoCapture &&\n        this.focusTrap.hasAttached()) {\n      this._captureFocus();\n    }\n  }\n\n  private _captureFocus() {\n    this._previouslyFocusedElement = _getFocusedElementPierceShadowDom();\n    this.focusTrap.focusInitialElementWhenReady();\n  }\n\n  static ngAcceptInputType_enabled: BooleanInput;\n  static ngAcceptInputType_autoCapture: BooleanInput;\n}\n"]}
|