@angular/cdk
Version:
Angular Material Component Development Kit
2,555 lines • 101 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, CommonModule } from '@angular/common';
import { Inject, Injectable, Optional, SkipSelf, QueryList, Directive, ElementRef, Input, NgZone, InjectionToken, EventEmitter, Output, NgModule, defineInjectable, inject } from '@angular/core';
import { Subject, Subscription, of } from 'rxjs';
import { UP_ARROW, DOWN_ARROW, LEFT_ARROW, RIGHT_ARROW, TAB, A, Z, ZERO, NINE } from '@angular/cdk/keycodes';
import { debounceTime, filter, map, tap, take } from 'rxjs/operators';
import { __extends } from 'tslib';
import { Platform, supportsPassiveEventListeners, PlatformModule } from '@angular/cdk/platform';
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { ContentObserver, ObserversModule } from '@angular/cdk/observers';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* IDs are deliminated by an empty space, as per the spec.
*/
var /** @type {?} */ ID_DELIMINATOR = ' ';
/**
* Adds the given ID to the specified ARIA attribute on an element.
* Used for attributes such as aria-labelledby, aria-owns, etc.
* @param {?} el
* @param {?} attr
* @param {?} id
* @return {?}
*/
function addAriaReferencedId(el, attr, id) {
var /** @type {?} */ ids = getAriaReferenceIds(el, attr);
if (ids.some(function (existingId) { return existingId.trim() == id.trim(); })) {
return;
}
ids.push(id.trim());
el.setAttribute(attr, ids.join(ID_DELIMINATOR));
}
/**
* Removes the given ID from the specified ARIA attribute on an element.
* Used for attributes such as aria-labelledby, aria-owns, etc.
* @param {?} el
* @param {?} attr
* @param {?} id
* @return {?}
*/
function removeAriaReferencedId(el, attr, id) {
var /** @type {?} */ ids = getAriaReferenceIds(el, attr);
var /** @type {?} */ filteredIds = ids.filter(function (val) { return val != id.trim(); });
el.setAttribute(attr, filteredIds.join(ID_DELIMINATOR));
}
/**
* Gets the list of IDs referenced by the given ARIA attribute on an element.
* Used for attributes such as aria-labelledby, aria-owns, etc.
* @param {?} el
* @param {?} attr
* @return {?}
*/
function getAriaReferenceIds(el, attr) {
// Get string array of all individual ids (whitespace deliminated) in the attribute value
return (el.getAttribute(attr) || '').match(/\S+/g) || [];
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* ID used for the body container where all messages are appended.
*/
var /** @type {?} */ MESSAGES_CONTAINER_ID = 'cdk-describedby-message-container';
/**
* ID prefix used for each created message element.
*/
var /** @type {?} */ CDK_DESCRIBEDBY_ID_PREFIX = 'cdk-describedby-message';
/**
* Attribute given to each host element that is described by a message element.
*/
var /** @type {?} */ CDK_DESCRIBEDBY_HOST_ATTRIBUTE = 'cdk-describedby-host';
/**
* Global incremental identifier for each registered message element.
*/
var /** @type {?} */ nextId = 0;
/**
* Global map of all registered message elements that have been placed into the document.
*/
var /** @type {?} */ messageRegistry = new Map();
/**
* Container for all registered messages.
*/
var /** @type {?} */ messagesContainer = null;
/**
* Utility that creates visually hidden elements with a message content. Useful for elements that
* want to use aria-describedby to further describe themselves without adding additional visual
* content.
* \@docs-private
*/
var AriaDescriber = /** @class */ (function () {
function AriaDescriber(_document) {
this._document = _document;
}
/**
* Adds to the host element an aria-describedby reference to a hidden element that contains
* the message. If the same message has already been registered, then it will reuse the created
* message element.
*/
/**
* Adds to the host element an aria-describedby reference to a hidden element that contains
* the message. If the same message has already been registered, then it will reuse the created
* message element.
* @param {?} hostElement
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype.describe = /**
* Adds to the host element an aria-describedby reference to a hidden element that contains
* the message. If the same message has already been registered, then it will reuse the created
* message element.
* @param {?} hostElement
* @param {?} message
* @return {?}
*/
function (hostElement, message) {
if (!this._canBeDescribed(hostElement, message)) {
return;
}
if (!messageRegistry.has(message)) {
this._createMessageElement(message);
}
if (!this._isElementDescribedByMessage(hostElement, message)) {
this._addMessageReference(hostElement, message);
}
};
/** Removes the host element's aria-describedby reference to the message element. */
/**
* Removes the host element's aria-describedby reference to the message element.
* @param {?} hostElement
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype.removeDescription = /**
* Removes the host element's aria-describedby reference to the message element.
* @param {?} hostElement
* @param {?} message
* @return {?}
*/
function (hostElement, message) {
if (!this._canBeDescribed(hostElement, message)) {
return;
}
if (this._isElementDescribedByMessage(hostElement, message)) {
this._removeMessageReference(hostElement, message);
}
var /** @type {?} */ registeredMessage = messageRegistry.get(message);
if (registeredMessage && registeredMessage.referenceCount === 0) {
this._deleteMessageElement(message);
}
if (messagesContainer && messagesContainer.childNodes.length === 0) {
this._deleteMessagesContainer();
}
};
/** Unregisters all created message elements and removes the message container. */
/**
* Unregisters all created message elements and removes the message container.
* @return {?}
*/
AriaDescriber.prototype.ngOnDestroy = /**
* Unregisters all created message elements and removes the message container.
* @return {?}
*/
function () {
var /** @type {?} */ describedElements = this._document.querySelectorAll("[" + CDK_DESCRIBEDBY_HOST_ATTRIBUTE + "]");
for (var /** @type {?} */ i = 0; i < describedElements.length; i++) {
this._removeCdkDescribedByReferenceIds(describedElements[i]);
describedElements[i].removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
}
if (messagesContainer) {
this._deleteMessagesContainer();
}
messageRegistry.clear();
};
/**
* Creates a new element in the visually hidden message container element with the message
* as its content and adds it to the message registry.
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype._createMessageElement = /**
* Creates a new element in the visually hidden message container element with the message
* as its content and adds it to the message registry.
* @param {?} message
* @return {?}
*/
function (message) {
var /** @type {?} */ messageElement = this._document.createElement('div');
messageElement.setAttribute('id', CDK_DESCRIBEDBY_ID_PREFIX + "-" + nextId++);
messageElement.appendChild(/** @type {?} */ ((this._document.createTextNode(message))));
this._createMessagesContainer(); /** @type {?} */
((messagesContainer)).appendChild(messageElement);
messageRegistry.set(message, { messageElement: messageElement, referenceCount: 0 });
};
/**
* Deletes the message element from the global messages container.
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype._deleteMessageElement = /**
* Deletes the message element from the global messages container.
* @param {?} message
* @return {?}
*/
function (message) {
var /** @type {?} */ registeredMessage = messageRegistry.get(message);
var /** @type {?} */ messageElement = registeredMessage && registeredMessage.messageElement;
if (messagesContainer && messageElement) {
messagesContainer.removeChild(messageElement);
}
messageRegistry.delete(message);
};
/**
* Creates the global container for all aria-describedby messages.
* @return {?}
*/
AriaDescriber.prototype._createMessagesContainer = /**
* Creates the global container for all aria-describedby messages.
* @return {?}
*/
function () {
if (!messagesContainer) {
var /** @type {?} */ preExistingContainer = this._document.getElementById(MESSAGES_CONTAINER_ID);
// When going from the server to the client, we may end up in a situation where there's
// already a container on the page, but we don't have a reference to it. Clear the
// old container so we don't get duplicates. Doing this, instead of emptying the previous
// container, should be slightly faster.
if (preExistingContainer) {
/** @type {?} */ ((preExistingContainer.parentNode)).removeChild(preExistingContainer);
}
messagesContainer = this._document.createElement('div');
messagesContainer.id = MESSAGES_CONTAINER_ID;
messagesContainer.setAttribute('aria-hidden', 'true');
messagesContainer.style.display = 'none';
this._document.body.appendChild(messagesContainer);
}
};
/**
* Deletes the global messages container.
* @return {?}
*/
AriaDescriber.prototype._deleteMessagesContainer = /**
* Deletes the global messages container.
* @return {?}
*/
function () {
if (messagesContainer && messagesContainer.parentNode) {
messagesContainer.parentNode.removeChild(messagesContainer);
messagesContainer = null;
}
};
/**
* Removes all cdk-describedby messages that are hosted through the element.
* @param {?} element
* @return {?}
*/
AriaDescriber.prototype._removeCdkDescribedByReferenceIds = /**
* Removes all cdk-describedby messages that are hosted through the element.
* @param {?} element
* @return {?}
*/
function (element) {
// Remove all aria-describedby reference IDs that are prefixed by CDK_DESCRIBEDBY_ID_PREFIX
var /** @type {?} */ originalReferenceIds = getAriaReferenceIds(element, 'aria-describedby')
.filter(function (id) { return id.indexOf(CDK_DESCRIBEDBY_ID_PREFIX) != 0; });
element.setAttribute('aria-describedby', originalReferenceIds.join(' '));
};
/**
* Adds a message reference to the element using aria-describedby and increments the registered
* message's reference count.
* @param {?} element
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype._addMessageReference = /**
* Adds a message reference to the element using aria-describedby and increments the registered
* message's reference count.
* @param {?} element
* @param {?} message
* @return {?}
*/
function (element, message) {
var /** @type {?} */ registeredMessage = /** @type {?} */ ((messageRegistry.get(message)));
// Add the aria-describedby reference and set the
// describedby_host attribute to mark the element.
addAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
element.setAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE, '');
registeredMessage.referenceCount++;
};
/**
* Removes a message reference from the element using aria-describedby
* and decrements the registered message's reference count.
* @param {?} element
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype._removeMessageReference = /**
* Removes a message reference from the element using aria-describedby
* and decrements the registered message's reference count.
* @param {?} element
* @param {?} message
* @return {?}
*/
function (element, message) {
var /** @type {?} */ registeredMessage = /** @type {?} */ ((messageRegistry.get(message)));
registeredMessage.referenceCount--;
removeAriaReferencedId(element, 'aria-describedby', registeredMessage.messageElement.id);
element.removeAttribute(CDK_DESCRIBEDBY_HOST_ATTRIBUTE);
};
/**
* Returns true if the element has been described by the provided message ID.
* @param {?} element
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype._isElementDescribedByMessage = /**
* Returns true if the element has been described by the provided message ID.
* @param {?} element
* @param {?} message
* @return {?}
*/
function (element, message) {
var /** @type {?} */ referenceIds = getAriaReferenceIds(element, 'aria-describedby');
var /** @type {?} */ registeredMessage = messageRegistry.get(message);
var /** @type {?} */ messageId = registeredMessage && registeredMessage.messageElement.id;
return !!messageId && referenceIds.indexOf(messageId) != -1;
};
/**
* Determines whether a message can be described on a particular element.
* @param {?} element
* @param {?} message
* @return {?}
*/
AriaDescriber.prototype._canBeDescribed = /**
* Determines whether a message can be described on a particular element.
* @param {?} element
* @param {?} message
* @return {?}
*/
function (element, message) {
return element.nodeType === this._document.ELEMENT_NODE && message != null &&
!!("" + message).trim();
};
AriaDescriber.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] },
];
/** @nocollapse */
AriaDescriber.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] },] },
]; };
/** @nocollapse */ AriaDescriber.ngInjectableDef = defineInjectable({ factory: function AriaDescriber_Factory() { return new AriaDescriber(inject(DOCUMENT)); }, token: AriaDescriber, providedIn: "root" });
return AriaDescriber;
}());
/**
* \@docs-private \@deprecated \@breaking-change 7.0.0
* @param {?} parentDispatcher
* @param {?} _document
* @return {?}
*/
function ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher, _document) {
return parentDispatcher || new AriaDescriber(_document);
}
/**
* \@docs-private \@deprecated \@breaking-change 7.0.0
*/
var /** @type {?} */ ARIA_DESCRIBER_PROVIDER = {
// If there is already an AriaDescriber available, use that. Otherwise, provide a new one.
provide: AriaDescriber,
deps: [
[new Optional(), new SkipSelf(), AriaDescriber],
/** @type {?} */ (DOCUMENT)
],
useFactory: ARIA_DESCRIBER_PROVIDER_FACTORY
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
// unsupported: template constraints.
/**
* This class manages keyboard events for selectable lists. If you pass it a query list
* of items, it will set the active item correctly when arrow events occur.
* @template T
*/
var
// unsupported: template constraints.
/**
* This class manages keyboard events for selectable lists. If you pass it a query list
* of items, it will set the active item correctly when arrow events occur.
* @template T
*/
ListKeyManager = /** @class */ (function () {
function ListKeyManager(_items) {
var _this = this;
this._items = _items;
this._activeItemIndex = -1;
this._wrap = false;
this._letterKeyStream = new Subject();
this._typeaheadSubscription = Subscription.EMPTY;
this._vertical = true;
/**
* Predicate function that can be used to check whether an item should be skipped
* by the key manager. By default, disabled items are skipped.
*/
this._skipPredicateFn = function (item) { return item.disabled; };
this._pressedLetters = [];
/**
* Stream that emits any time the TAB key is pressed, so components can react
* when focus is shifted off of the list.
*/
this.tabOut = new Subject();
/**
* Stream that emits whenever the active item of the list manager changes.
*/
this.change = new Subject();
// We allow for the items to be an array because, in some cases, the consumer may
// not have access to a QueryList of the items they want to manage (e.g. when the
// items aren't being collected via `ViewChildren` or `ContentChildren`).
if (_items instanceof QueryList) {
_items.changes.subscribe(function (newItems) {
if (_this._activeItem) {
var /** @type {?} */ itemArray = newItems.toArray();
var /** @type {?} */ newIndex = itemArray.indexOf(_this._activeItem);
if (newIndex > -1 && newIndex !== _this._activeItemIndex) {
_this._activeItemIndex = newIndex;
}
}
});
}
}
/**
* Sets the predicate function that determines which items should be skipped by the
* list key manager.
* @param predicate Function that determines whether the given item should be skipped.
*/
/**
* Sets the predicate function that determines which items should be skipped by the
* list key manager.
* @param {?} predicate Function that determines whether the given item should be skipped.
* @return {?}
*/
ListKeyManager.prototype.skipPredicate = /**
* Sets the predicate function that determines which items should be skipped by the
* list key manager.
* @param {?} predicate Function that determines whether the given item should be skipped.
* @return {?}
*/
function (predicate) {
this._skipPredicateFn = predicate;
return this;
};
/**
* Configures wrapping mode, which determines whether the active item will wrap to
* the other end of list when there are no more items in the given direction.
* @param shouldWrap Whether the list should wrap when reaching the end.
*/
/**
* Configures wrapping mode, which determines whether the active item will wrap to
* the other end of list when there are no more items in the given direction.
* @param {?=} shouldWrap Whether the list should wrap when reaching the end.
* @return {?}
*/
ListKeyManager.prototype.withWrap = /**
* Configures wrapping mode, which determines whether the active item will wrap to
* the other end of list when there are no more items in the given direction.
* @param {?=} shouldWrap Whether the list should wrap when reaching the end.
* @return {?}
*/
function (shouldWrap) {
if (shouldWrap === void 0) { shouldWrap = true; }
this._wrap = shouldWrap;
return this;
};
/**
* Configures whether the key manager should be able to move the selection vertically.
* @param enabled Whether vertical selection should be enabled.
*/
/**
* Configures whether the key manager should be able to move the selection vertically.
* @param {?=} enabled Whether vertical selection should be enabled.
* @return {?}
*/
ListKeyManager.prototype.withVerticalOrientation = /**
* Configures whether the key manager should be able to move the selection vertically.
* @param {?=} enabled Whether vertical selection should be enabled.
* @return {?}
*/
function (enabled) {
if (enabled === void 0) { enabled = true; }
this._vertical = enabled;
return this;
};
/**
* Configures the key manager to move the selection horizontally.
* Passing in `null` will disable horizontal movement.
* @param direction Direction in which the selection can be moved.
*/
/**
* Configures the key manager to move the selection horizontally.
* Passing in `null` will disable horizontal movement.
* @param {?} direction Direction in which the selection can be moved.
* @return {?}
*/
ListKeyManager.prototype.withHorizontalOrientation = /**
* Configures the key manager to move the selection horizontally.
* Passing in `null` will disable horizontal movement.
* @param {?} direction Direction in which the selection can be moved.
* @return {?}
*/
function (direction) {
this._horizontal = direction;
return this;
};
/**
* Turns on typeahead mode which allows users to set the active item by typing.
* @param debounceInterval Time to wait after the last keystroke before setting the active item.
*/
/**
* Turns on typeahead mode which allows users to set the active item by typing.
* @param {?=} debounceInterval Time to wait after the last keystroke before setting the active item.
* @return {?}
*/
ListKeyManager.prototype.withTypeAhead = /**
* Turns on typeahead mode which allows users to set the active item by typing.
* @param {?=} debounceInterval Time to wait after the last keystroke before setting the active item.
* @return {?}
*/
function (debounceInterval) {
var _this = this;
if (debounceInterval === void 0) { debounceInterval = 200; }
if (this._items.length && this._items.some(function (item) { return typeof item.getLabel !== 'function'; })) {
throw Error('ListKeyManager items in typeahead mode must implement the `getLabel` method.');
}
this._typeaheadSubscription.unsubscribe();
// Debounce the presses of non-navigational keys, collect the ones that correspond to letters
// and convert those letters back into a string. Afterwards find the first item that starts
// with that string and select it.
this._typeaheadSubscription = this._letterKeyStream.pipe(tap(function (keyCode) { return _this._pressedLetters.push(keyCode); }), debounceTime(debounceInterval), filter(function () { return _this._pressedLetters.length > 0; }), map(function () { return _this._pressedLetters.join(''); })).subscribe(function (inputString) {
var /** @type {?} */ items = _this._getItemsArray();
// Start at 1 because we want to start searching at the item immediately
// following the current active item.
for (var /** @type {?} */ i = 1; i < items.length + 1; i++) {
var /** @type {?} */ index = (_this._activeItemIndex + i) % items.length;
var /** @type {?} */ item = items[index];
if (!_this._skipPredicateFn(item) && /** @type {?} */ ((item.getLabel))().toUpperCase().trim().indexOf(inputString) === 0) {
_this.setActiveItem(index);
break;
}
}
_this._pressedLetters = [];
});
return this;
};
/**
* @param {?} item
* @return {?}
*/
ListKeyManager.prototype.setActiveItem = /**
* @param {?} item
* @return {?}
*/
function (item) {
var /** @type {?} */ previousIndex = this._activeItemIndex;
this.updateActiveItem(item);
if (this._activeItemIndex !== previousIndex) {
this.change.next(this._activeItemIndex);
}
};
/**
* Sets the active item depending on the key event passed in.
* @param event Keyboard event to be used for determining which element should be active.
*/
/**
* Sets the active item depending on the key event passed in.
* @param {?} event Keyboard event to be used for determining which element should be active.
* @return {?}
*/
ListKeyManager.prototype.onKeydown = /**
* Sets the active item depending on the key event passed in.
* @param {?} event Keyboard event to be used for determining which element should be active.
* @return {?}
*/
function (event) {
var /** @type {?} */ keyCode = event.keyCode;
switch (keyCode) {
case TAB:
this.tabOut.next();
return;
case DOWN_ARROW:
if (this._vertical) {
this.setNextItemActive();
break;
}
else {
return;
}
case UP_ARROW:
if (this._vertical) {
this.setPreviousItemActive();
break;
}
else {
return;
}
case RIGHT_ARROW:
if (this._horizontal === 'ltr') {
this.setNextItemActive();
break;
}
else if (this._horizontal === 'rtl') {
this.setPreviousItemActive();
break;
}
else {
return;
}
case LEFT_ARROW:
if (this._horizontal === 'ltr') {
this.setPreviousItemActive();
break;
}
else if (this._horizontal === 'rtl') {
this.setNextItemActive();
break;
}
else {
return;
}
default:
// Attempt to use the `event.key` which also maps it to the user's keyboard language,
// otherwise fall back to resolving alphanumeric characters via the keyCode.
if (event.key && event.key.length === 1) {
this._letterKeyStream.next(event.key.toLocaleUpperCase());
}
else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {
this._letterKeyStream.next(String.fromCharCode(keyCode));
}
// Note that we return here, in order to avoid preventing
// the default action of non-navigational keys.
return;
}
this._pressedLetters = [];
event.preventDefault();
};
Object.defineProperty(ListKeyManager.prototype, "activeItemIndex", {
/** Index of the currently active item. */
get: /**
* Index of the currently active item.
* @return {?}
*/
function () {
return this._activeItemIndex;
},
enumerable: true,
configurable: true
});
Object.defineProperty(ListKeyManager.prototype, "activeItem", {
/** The active item. */
get: /**
* The active item.
* @return {?}
*/
function () {
return this._activeItem;
},
enumerable: true,
configurable: true
});
/** Sets the active item to the first enabled item in the list. */
/**
* Sets the active item to the first enabled item in the list.
* @return {?}
*/
ListKeyManager.prototype.setFirstItemActive = /**
* Sets the active item to the first enabled item in the list.
* @return {?}
*/
function () {
this._setActiveItemByIndex(0, 1);
};
/** Sets the active item to the last enabled item in the list. */
/**
* Sets the active item to the last enabled item in the list.
* @return {?}
*/
ListKeyManager.prototype.setLastItemActive = /**
* Sets the active item to the last enabled item in the list.
* @return {?}
*/
function () {
this._setActiveItemByIndex(this._items.length - 1, -1);
};
/** Sets the active item to the next enabled item in the list. */
/**
* Sets the active item to the next enabled item in the list.
* @return {?}
*/
ListKeyManager.prototype.setNextItemActive = /**
* Sets the active item to the next enabled item in the list.
* @return {?}
*/
function () {
this._activeItemIndex < 0 ? this.setFirstItemActive() : this._setActiveItemByDelta(1);
};
/** Sets the active item to a previous enabled item in the list. */
/**
* Sets the active item to a previous enabled item in the list.
* @return {?}
*/
ListKeyManager.prototype.setPreviousItemActive = /**
* Sets the active item to a previous enabled item in the list.
* @return {?}
*/
function () {
this._activeItemIndex < 0 && this._wrap ? this.setLastItemActive()
: this._setActiveItemByDelta(-1);
};
/**
* @param {?} item
* @return {?}
*/
ListKeyManager.prototype.updateActiveItem = /**
* @param {?} item
* @return {?}
*/
function (item) {
var /** @type {?} */ itemArray = this._getItemsArray();
var /** @type {?} */ index = typeof item === 'number' ? item : itemArray.indexOf(item);
this._activeItemIndex = index;
this._activeItem = itemArray[index];
};
/**
* Allows setting of the activeItemIndex without any other effects.
* @param index The new activeItemIndex.
* @deprecated Use `updateActiveItem` instead.
* @breaking-change 7.0.0
*/
/**
* Allows setting of the activeItemIndex without any other effects.
* @deprecated Use `updateActiveItem` instead.
* \@breaking-change 7.0.0
* @param {?} index The new activeItemIndex.
* @return {?}
*/
ListKeyManager.prototype.updateActiveItemIndex = /**
* Allows setting of the activeItemIndex without any other effects.
* @deprecated Use `updateActiveItem` instead.
* \@breaking-change 7.0.0
* @param {?} index The new activeItemIndex.
* @return {?}
*/
function (index) {
this.updateActiveItem(index);
};
/**
* This method sets the active item, given a list of items and the delta between the
* currently active item and the new active item. It will calculate differently
* depending on whether wrap mode is turned on.
* @param {?} delta
* @return {?}
*/
ListKeyManager.prototype._setActiveItemByDelta = /**
* This method sets the active item, given a list of items and the delta between the
* currently active item and the new active item. It will calculate differently
* depending on whether wrap mode is turned on.
* @param {?} delta
* @return {?}
*/
function (delta) {
this._wrap ? this._setActiveInWrapMode(delta) : this._setActiveInDefaultMode(delta);
};
/**
* Sets the active item properly given "wrap" mode. In other words, it will continue to move
* down the list until it finds an item that is not disabled, and it will wrap if it
* encounters either end of the list.
* @param {?} delta
* @return {?}
*/
ListKeyManager.prototype._setActiveInWrapMode = /**
* Sets the active item properly given "wrap" mode. In other words, it will continue to move
* down the list until it finds an item that is not disabled, and it will wrap if it
* encounters either end of the list.
* @param {?} delta
* @return {?}
*/
function (delta) {
var /** @type {?} */ items = this._getItemsArray();
for (var /** @type {?} */ i = 1; i <= items.length; i++) {
var /** @type {?} */ index = (this._activeItemIndex + (delta * i) + items.length) % items.length;
var /** @type {?} */ item = items[index];
if (!this._skipPredicateFn(item)) {
this.setActiveItem(index);
return;
}
}
};
/**
* Sets the active item properly given the default mode. In other words, it will
* continue to move down the list until it finds an item that is not disabled. If
* it encounters either end of the list, it will stop and not wrap.
* @param {?} delta
* @return {?}
*/
ListKeyManager.prototype._setActiveInDefaultMode = /**
* Sets the active item properly given the default mode. In other words, it will
* continue to move down the list until it finds an item that is not disabled. If
* it encounters either end of the list, it will stop and not wrap.
* @param {?} delta
* @return {?}
*/
function (delta) {
this._setActiveItemByIndex(this._activeItemIndex + delta, delta);
};
/**
* Sets the active item to the first enabled item starting at the index specified. If the
* item is disabled, it will move in the fallbackDelta direction until it either
* finds an enabled item or encounters the end of the list.
* @param {?} index
* @param {?} fallbackDelta
* @return {?}
*/
ListKeyManager.prototype._setActiveItemByIndex = /**
* Sets the active item to the first enabled item starting at the index specified. If the
* item is disabled, it will move in the fallbackDelta direction until it either
* finds an enabled item or encounters the end of the list.
* @param {?} index
* @param {?} fallbackDelta
* @return {?}
*/
function (index, fallbackDelta) {
var /** @type {?} */ items = this._getItemsArray();
if (!items[index]) {
return;
}
while (this._skipPredicateFn(items[index])) {
index += fallbackDelta;
if (!items[index]) {
return;
}
}
this.setActiveItem(index);
};
/**
* Returns the items as an array.
* @return {?}
*/
ListKeyManager.prototype._getItemsArray = /**
* Returns the items as an array.
* @return {?}
*/
function () {
return this._items instanceof QueryList ? this._items.toArray() : this._items;
};
return ListKeyManager;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @template T
*/
var /**
* @template T
*/
ActiveDescendantKeyManager = /** @class */ (function (_super) {
__extends(ActiveDescendantKeyManager, _super);
function ActiveDescendantKeyManager() {
return _super !== null && _super.apply(this, arguments) || this;
}
/**
* @param {?} index
* @return {?}
*/
ActiveDescendantKeyManager.prototype.setActiveItem = /**
* @param {?} index
* @return {?}
*/
function (index) {
if (this.activeItem) {
this.activeItem.setInactiveStyles();
}
_super.prototype.setActiveItem.call(this, index);
if (this.activeItem) {
this.activeItem.setActiveStyles();
}
};
return ActiveDescendantKeyManager;
}(ListKeyManager));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @template T
*/
var /**
* @template T
*/
FocusKeyManager = /** @class */ (function (_super) {
__extends(FocusKeyManager, _super);
function FocusKeyManager() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this._origin = 'program';
return _this;
}
/**
* Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.
* @param origin Focus origin to be used when focusing items.
*/
/**
* Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.
* @param {?} origin Focus origin to be used when focusing items.
* @return {?}
*/
FocusKeyManager.prototype.setFocusOrigin = /**
* Sets the focus origin that will be passed in to the items for any subsequent `focus` calls.
* @param {?} origin Focus origin to be used when focusing items.
* @return {?}
*/
function (origin) {
this._origin = origin;
return this;
};
/**
* @param {?} item
* @return {?}
*/
FocusKeyManager.prototype.setActiveItem = /**
* @param {?} item
* @return {?}
*/
function (item) {
_super.prototype.setActiveItem.call(this, item);
if (this.activeItem) {
this.activeItem.focus(this._origin);
}
};
return FocusKeyManager;
}(ListKeyManager));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* Utility for checking the interactivity of an element, such as whether is is focusable or
* tabbable.
*/
var InteractivityChecker = /** @class */ (function () {
function InteractivityChecker(_platform) {
this._platform = _platform;
}
/**
* Gets whether an element is disabled.
*
* @param element Element to be checked.
* @returns Whether the element is disabled.
*/
/**
* Gets whether an element is disabled.
*
* @param {?} element Element to be checked.
* @return {?} Whether the element is disabled.
*/
InteractivityChecker.prototype.isDisabled = /**
* Gets whether an element is disabled.
*
* @param {?} element Element to be checked.
* @return {?} Whether the element is disabled.
*/
function (element) {
// This does not capture some cases, such as a non-form control with a disabled attribute or
// a form control inside of a disabled form, but should capture the most common cases.
return element.hasAttribute('disabled');
};
/**
* Gets whether an element is visible for the purposes of interactivity.
*
* This will capture states like `display: none` and `visibility: hidden`, but not things like
* being clipped by an `overflow: hidden` parent or being outside the viewport.
*
* @returns Whether the element is visible.
*/
/**
* Gets whether an element is visible for the purposes of interactivity.
*
* This will capture states like `display: none` and `visibility: hidden`, but not things like
* being clipped by an `overflow: hidden` parent or being outside the viewport.
*
* @param {?} element
* @return {?} Whether the element is visible.
*/
InteractivityChecker.prototype.isVisible = /**
* Gets whether an element is visible for the purposes of interactivity.
*
* This will capture states like `display: none` and `visibility: hidden`, but not things like
* being clipped by an `overflow: hidden` parent or being outside the viewport.
*
* @param {?} element
* @return {?} Whether the element is visible.
*/
function (element) {
return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
};
/**
* Gets whether an element can be reached via Tab key.
* Assumes that the element has already been checked with isFocusable.
*
* @param element Element to be checked.
* @returns Whether the element is tabbable.
*/
/**
* Gets whether an element can be reached via Tab key.
* Assumes that the element has already been checked with isFocusable.
*
* @param {?} element Element to be checked.
* @return {?} Whether the element is tabbable.
*/
InteractivityChecker.prototype.isTabbable = /**
* Gets whether an element can be reached via Tab key.
* Assumes that the element has already been checked with isFocusable.
*
* @param {?} element Element to be checked.
* @return {?} Whether the element is tabbable.
*/
function (element) {
// Nothing is tabbable on the the server 😎
if (!this._platform.isBrowser) {
return false;
}
var /** @type {?} */ frameElement = getFrameElement(getWindow(element));
if (frameElement) {
var /** @type {?} */ frameType = frameElement && frameElement.nodeName.toLowerCase();
// Frame elements inherit their tabindex onto all child elements.
if (getTabIndexValue(frameElement) === -1) {
return false;
}
// Webkit and Blink consider anything inside of an <object> element as non-tabbable.
if ((this._platform.BLINK || this._platform.WEBKIT) && frameType === 'object') {
return false;
}
// Webkit and Blink disable tabbing to an element inside of an invisible frame.
if ((this._platform.BLINK || this._platform.WEBKIT) && !this.isVisible(frameElement)) {
return false;
}
}
var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
var /** @type {?} */ tabIndexValue = getTabIndexValue(element);
if (element.hasAttribute('contenteditable')) {
return tabIndexValue !== -1;
}
if (nodeName === 'iframe') {
// The frames may be tabbable depending on content, but it's not possibly to reliably
// investigate the content of the frames.
return false;
}
if (nodeName === 'audio') {
if (!element.hasAttribute('controls')) {
// By default an <audio> element without the controls enabled is not tabbable.
return false;
}
else if (this._platform.BLINK) {
// In Blink <audio controls> elements are always tabbable.
return true;
}
}
if (nodeName === 'video') {
if (!element.hasAttribute('controls') && this._platform.TRIDENT) {
// In Trident a <video> element without the controls enabled is not tabbable.
return false;
}
else if (this._platform.BLINK || this._platform.FIREFOX) {
// In Chrome and Firefox <video controls> elements are always tabbable.
return true;
}
}
if (nodeName === 'object' && (this._platform.BLINK || this._platform.WEBKIT)) {
// In all Blink and WebKit based browsers <object> elements are never tabbable.
return false;
}
// In iOS the browser only considers some specific elements as tabbable.
if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {
return false;
}
return element.tabIndex >= 0;
};
/**
* Gets whether an element can be focused by the user.
*
* @param element Element to be checked.
* @returns Whether the element is focusable.
*/
/**
* Gets whether an element can be focused by the user.
*
* @param {?} element Element to be checked.
* @return {?} Whether the element is focusable.
*/
InteractivityChecker.prototype.isFocusable = /**
* Gets whether an element can be focused by the user.
*
* @param {?} element Element to be checked.
* @return {?} Whether the element is focusable.
*/
function (element) {
// Perform checks in order of left to most expensive.
// Again, naive approach that does not capture many edge cases and browser quirks.
return isPotentiallyFocusable(element) && !this.isDisabled(element) && this.isVisible(element);
};
InteractivityChecker.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] },
];
/** @nocollapse */
InteractivityChecker.ctorParameters = function () { return [
{ type: Platform, },
]; };
/** @nocollapse */ InteractivityChecker.ngInjectableDef = defineInjectable({ factory: function InteractivityChecker_Factory() { return new InteractivityChecker(inject(Platform)); }, token: InteractivityChecker, providedIn: "root" });
return InteractivityChecker;
}());
/**
* Returns the frame element from a window object. Since browsers like MS Edge throw errors if
* the frameElement property is being accessed from a different host address, this property
* should be accessed carefully.
* @param {?} window
* @return {?}
*/
function getFrameElement(window) {
try {
return /** @type {?} */ (window.frameElement);
}
catch (/** @type {?} */ e) {
return null;
}
}
/**
* Checks whether the specified element has any geometry / rectangles.
* @param {?} element
* @return {?}
*/
function hasGeometry(element) {
// Use logic from jQuery to check for an invisible element.
// See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
return !!(element.offsetWidth || element.offsetHeight ||
(typeof element.getClientRects === 'function' && element.getClientRects().length));
}
/**
* Gets whether an element's
* @param {?} element
* @return {?}
*/
function isNativeFormElement(element) {
var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
return nodeName === 'input' ||
nodeName === 'select' ||
nodeName === 'button' ||
nodeName === 'textarea';
}
/**
* Gets whether an element is an `<input type="hidden">`.
* @param {?} element
* @return {?}
*/
function isHiddenInput(element) {
return isInputElement(element) && element.type == 'hidden';
}
/**
* Gets whether an element is an anchor that has an href attribute.
* @param {?} element
* @return {?}
*/
function isAnchorWithHref(element) {
return isAnchorElement(element) && element.hasAttribute('href');
}
/**
* Gets whether an element is an input element.
* @param {?} element
* @return {?}
*/
function isInputElement(element) {
return element.nodeName.toLowerCase() == 'input';
}
/**
* Gets whether an element is an anchor element.
* @param {?} element
* @return {?}
*/
function isAnchorElement(element) {
return element.nodeName.toLowerCase() == 'a';
}
/**
* Gets whether an element has a valid tabindex.
* @param {?} element
* @return {?}
*/
function hasValidTabIndex(element) {
if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {
return false;
}
var /** @type {?} */ tabIndex = element.getAttribute('tabindex');
// IE11 parses tabindex="" as the value "-32768"
if (tabIndex == '-32768') {
return false;
}
return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
}
/**
* Returns the parsed tabindex from the element attributes instead of returning the
* evaluated tabindex from the browsers defaults.
* @param {?} element
* @return {?}
*/
function getTabIndexValue(element) {
if (!hasValidTabIndex(element)) {
return null;
}
// See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
var /** @type {?} */ tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);
return isNaN(tabIndex) ? -1 : tabIndex;
}
/**
* Checks whether the specified element is potentially tabbable on iOS
* @param {?} element
* @return {?}
*/
function isPotentiallyTabbableIOS(element) {
var /** @type {?} */ nodeName = element.nodeName.toLowerCase();
var /** @type {?} */ inputType = nodeName === 'input' && (/** @type {?} */ (element)).type;
return inputType === 'text'
|| inputType === 'password'
|| nodeName === 'select'
|| nodeName === 'textarea';
}
/**
* Gets whether an element is potentially focusable without taking current visible/disabled state
* into account.
* @param {?} element
* @return {?}
*/
function isPotentiallyFocusable(element) {
// Inputs are potentially focusable *unless* they're type="hidden".
if (isHiddenInput(element)) {
return false;
}
return isNativeFormElement(element) ||
isAnchorWithHref(element) ||
element.hasAttribute('contenteditable') ||
hasValidTabIndex(element);
}
/**
* Gets the parent window of a DOM node with regards of being inside of an iframe.
* @param {?} node
* @return {?}
*/
function getWindow(node) {
return node.ownerDocument.defaultView || window;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* 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 to two to misalign.
*/
var /**
* 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 to two to misalign.
*/
FocusTrap = /** @class */ (function () {
function FocusTrap(_element, _checker, _ngZone, _document, deferAnchors) {
if (deferAnchors === void 0) { deferAnchors = false; }
this._element = _element;
this._checker = _checker;
this._ngZone = _ngZone;
this._document = _document;
this._hasAttached = false;
this._enabled = true;
if (!deferAnchors) {
this.attachAnchors();
}
}
Object.defineProperty(FocusTrap.prototype, "enabled", {
/** Whether the focus trap is active. */
get: /**
* Whether the focus trap is active.
* @return {?}
*/
function () { return this._enabled; },
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._enabled = val;
if (this._startAnchor && this._endAnchor) {
this._startAnchor.tabIndex = this._endAnchor.tabIndex = this._enabled ? 0 : -1;
}
},
enumerable: true,
configurable: true
});
/** Destroys the focus trap by cleaning up the anchors. */
/**
* Destroys the focus trap by cleaning up the anchors.
* @return {?}
*/
FocusTrap.prototype.destroy = /**
* Destroys the focus trap by cleaning up the anchors.
* @return {?}
*/
function () {
if (this._startAnchor && this._startAnchor.parentNode) {
this._startAnchor.parentNode.removeChild(this._startAnchor);
}
if (this._endAnchor && this._endAnchor.parentNode) {
this._endAnchor.parentNode.removeChild(this._endAnchor);
}
this._startAnchor = this._endAnchor = null;
};
/**
* 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 successfuly. This may not be the case
* if the target element isn't currently in the DOM.
*/
/**
* Inserts the anchors into the DOM. This is usually done automatically
* in the constructor, but can be deferred for cases like directives with `*ngIf`.
* @return {?} Whether the focus trap managed to attach successfuly. This may not be the case
* if the target element isn't currently in the DOM.
*/
FocusTrap.prototype.attachAnchors = /**
* Inserts the anchors into the DOM. This is usually done automatically
* in the constructor, but can be deferred for cases like directives with `*ngIf`.
* @return {?} Whether the focus trap managed to attach successfuly. This may not be the case
* if the target element isn't currently in the DOM.
*/
function () {
var _this = this;
// If we're not on the browser, there can be no focus to trap.
if (this._hasAttached) {
return true;
}
this._ngZone.runOutsideAngular(function () {
if (!_this._startAnchor) {
_this._startAnchor = _this._createAnchor(); /** @type {?} */
((_this._startAnchor)).addEventListener('focus', function () { return _this.focusLastTabbableElement(); });
}
if (!_this._endAnchor) {
_this._endAnchor = _this._createAnchor(); /** @type {?} */
((_this._endAnchor)).addEventListener('focus', function () { return _this.focusFirstTabbableElement(); });
}
});
if (this._element.parentNode) {
this._element.parentNode.insertBefore(/** @type {?} */ ((this._startAnchor)), this._element);
this._element.parentNode.insertBefore(/** @type {?} */ ((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 successfuly.
*/
/**
* Waits for the zone to stabilize, then either focuses the first element that the
* user specified, or the first tabbable element.
* @return {?} Returns a promise that resolves with a boolean, depending
* on whether focus was moved successfuly.
*/
FocusTrap.prototype.focusInitialElementWhenReady = /**
* Waits for the zone to stabilize, then either focuses the first element that the
* user specified, or the first tabbable element.
* @return {?} Returns a promise that resolves with a boolean, depending
* on whether focus was moved successfuly.
*/
function () {
var _this = this;
return new Promise(function (resolve) {
_this._executeOnStable(function () { return resolve(_this.focusInitialElement()); });
});
};
/**
* 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 successfuly.
*/
/**
* Waits for the zone to stabilize, then focuses
* the first tabbable element within the focus trap region.
* @return {?} Returns a promise that resolves with a boolean, depending
* on whether focus was moved successfuly.
*/
FocusTrap.prototype.focusFirstTabbableElementWhenReady = /**
* Waits for the zone to stabilize, then focuses
* the first tabbable element within the focus trap region.
* @return {?} Returns a promise that resolves with a boolean, depending
* on whether focus was moved successfuly.
*/
function () {
var _this = this;
return new Promise(function (resolve) {
_this._executeOnStable(function () { return resolve(_this.focusFirstTabbableElement()); });
});
};
/**
* 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 successfuly.
*/
/**
* Waits for the zone to stabilize, then focuses
* the last tabbable element within the focus trap region.
* @return {?} Returns a promise that resolves with a boolean, depending
* on whether focus was moved successfuly.
*/
FocusTrap.prototype.focusLastTabbableElementWhenReady = /**
* Waits for the zone to stabilize, then focuses
* the last tabbable element within the focus trap region.
* @return {?} Returns a promise that resolves with a boolean, depending
* on whether focus was moved successfuly.
*/
function () {
var _this = this;
return new Promise(function (resolve) {
_this._executeOnStable(function () { return resolve(_this.focusLastTabbableElement()); });
});
};
/**
* Get the specified boundary element of the trapped region.
* @param {?} bound The boundary to get (start or end of trapped region).
* @return {?} The boundary element.
*/
FocusTrap.prototype._getRegionBoundary = /**
* Get the specified boundary element of the trapped region.
* @param {?} bound The boundary to get (start or end of trapped region).
* @return {?} The boundary element.
*/
function (bound) {
// Contains the deprecated version of selector, for temporary backwards comparability.
var /** @type {?} */ markers = /** @type {?} */ (this._element.querySelectorAll("[cdk-focus-region-" + bound + "], " +
("[cdkFocusRegion" + bound + "], ") +
("[cdk-focus-" + bound + "]")));
for (var /** @type {?} */ i = 0; i < markers.length; i++) {
// @breaking-change 7.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 7.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 7.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 successfuly.
*/
/**
* Focuses the element that should be focused when the focus trap is initialized.
* @return {?} Whether focus was moved successfuly.
*/
FocusTrap.prototype.focusInitialElement = /**
* Focuses the element that should be focused when the focus trap is initialized.
* @return {?} Whether focus was moved successfuly.
*/
function () {
// Contains the deprecated version of selector, for temporary backwards comparability.
var /** @type {?} */ redirectToElement = /** @type {?} */ (this._element.querySelector("[cdk-focus-initial], " +
"[cdkFocusInitial]"));
if (redirectToElement) {
// @breaking-change 7.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 7.0.0", redirectToElement);
}
redirectToElement.focus();
return true;
}
return this.focusFirstTabbableElement();
};
/**
* Focuses the first tabbable element within the focus trap region.
* @returns Whether focus was moved successfuly.
*/
/**
* Focuses the first tabbable element within the focus trap region.
* @return {?} Whether focus was moved successfuly.
*/
FocusTrap.prototype.focusFirstTabbableElement = /**
* Focuses the first tabbable element within the focus trap region.
* @return {?} Whether focus was moved successfuly.
*/
function () {
var /** @type {?} */ redirectToElement = this._getRegionBoundary('start');
if (redirectToElement) {
redirectToElement.focus();
}
return !!redirectToElement;
};
/**
* Focuses the last tabbable element within the focus trap region.
* @returns Whether focus was moved successfuly.
*/
/**
* Focuses the last tabbable element within the focus trap region.
* @return {?} Whether focus was moved successfuly.
*/
FocusTrap.prototype.focusLastTabbableElement = /**
* Focuses the last tabbable element within the focus trap region.
* @return {?} Whether focus was moved successfuly.
*/
function () {
var /** @type {?} */ redirectToElement = this._getRegionBoundary('end');
if (redirectToElement) {
redirectToElement.focus();
}
return !!redirectToElement;
};
/**
* Checks whether the focus trap has successfuly been attached.
*/
/**
* Checks whether the focus trap has successfuly been attached.
* @return {?}
*/
FocusTrap.prototype.hasAttached = /**
* Checks whether the focus trap has successfuly been attached.
* @return {?}
*/
function () {
return this._hasAttached;
};
/**
* Get the first tabbable element from a DOM subtree (inclusive).
* @param {?} root
* @return {?}
*/
FocusTrap.prototype._getFirstTabbableElement = /**
* Get the first tabbable element from a DOM subtree (inclusive).
* @param {?} root
* @return {?}
*/
function (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.
var /** @type {?} */ children = root.children || root.childNodes;
for (var /** @type {?} */ i = 0; i < children.length; i++) {
var /** @type {?} */ tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?
this._getFirstTabbableElement(/** @type {?} */ (children[i])) :
null;
if (tabbableChild) {
return tabbableChild;
}
}
return null;
};
/**
* Get the last tabbable element from a DOM subtree (inclusive).
* @param {?} root
* @return {?}
*/
FocusTrap.prototype._getLastTabbableElement = /**
* Get the last tabbable element from a DOM subtree (inclusive).
* @param {?} root
* @return {?}
*/
function (root) {
if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
return root;
}
// Iterate in reverse DOM order.
var /** @type {?} */ children = root.children || root.childNodes;
for (var /** @type {?} */ i = children.length - 1; i >= 0; i--) {
var /** @type {?} */ tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE ?
this._getLastTabbableElement(/** @type {?} */ (children[i])) :
null;
if (tabbableChild) {
return tabbableChild;
}
}
return null;
};
/**
* Creates an anchor element.
* @return {?}
*/
FocusTrap.prototype._createAnchor = /**
* Creates an anchor element.
* @return {?}
*/
function () {
var /** @type {?} */ anchor = this._document.createElement('div');
anchor.tabIndex = this._enabled ? 0 : -1;
anchor.classList.add('cdk-visually-hidden');
anchor.classList.add('cdk-focus-trap-anchor');
return anchor;
};
/**
* Executes a function when the zone is stable.
* @param {?} fn
* @return {?}
*/
FocusTrap.prototype._executeOnStable = /**
* Executes a function when the zone is stable.
* @param {?} fn
* @return {?}
*/
function (fn) {
if (this._ngZone.isStable) {
fn();
}
else {
this._ngZone.onStable.asObservable().pipe(take(1)).subscribe(fn);
}
};
return FocusTrap;
}());
/**
* Factory that allows easy instantiation of focus traps.
*/
var FocusTrapFactory = /** @class */ (function () {
function FocusTrapFactory(_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.
*/
/**
* 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.
* @return {?} The created focus trap instance.
*/
FocusTrapFactory.prototype.create = /**
* 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.
* @return {?} The created focus trap instance.
*/
function (element, deferCaptureElements) {
if (deferCaptureElements === void 0) { deferCaptureElements = false; }
return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);
};
FocusTrapFactory.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] },
];
/** @nocollapse */
FocusTrapFactory.ctorParameters = function () { return [
{ type: InteractivityChecker, },
{ type: NgZone, },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] },] },
]; };
/** @nocollapse */ FocusTrapFactory.ngInjectableDef = defineInjectable({ factory: function FocusTrapFactory_Factory() { return new FocusTrapFactory(inject(InteractivityChecker), inject(NgZone), inject(DOCUMENT)); }, token: FocusTrapFactory, providedIn: "root" });
return FocusTrapFactory;
}());
/**
* Directive for trapping focus within a region.
*/
var CdkTrapFocus = /** @class */ (function () {
function CdkTrapFocus(_elementRef, _focusTrapFactory, _document) {
this._elementRef = _elementRef;
this._focusTrapFactory = _focusTrapFactory;
/**
* Previously focused element to restore focus to upon destroy when using autoCapture.
*/
this._previouslyFocusedElement = null;
this._document = _document;
this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
}
Object.defineProperty(CdkTrapFocus.prototype, "enabled", {
get: /**
* Whether the focus trap is active.
* @return {?}
*/
function () { return this.focusTrap.enabled; },
set: /**
* @param {?} value
* @return {?}
*/
function (value) { this.focusTrap.enabled = coerceBooleanProperty(value); },
enumerable: true,
configurable: true
});
Object.defineProperty(CdkTrapFocus.prototype, "autoCapture", {
get: /**
* Whether the directive should automatially move focus into the trapped region upon
* initialization and return focus to the previous activeElement upon destruction.
* @return {?}
*/
function () { return this._autoCapture; },
set: /**
* @param {?} value
* @return {?}
*/
function (value) { this._autoCapture = coerceBooleanProperty(value); },
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
CdkTrapFocus.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
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;
}
};
/**
* @return {?}
*/
CdkTrapFocus.prototype.ngAfterContentInit = /**
* @return {?}
*/
function () {
this.focusTrap.attachAnchors();
if (this.autoCapture) {
this._previouslyFocusedElement = /** @type {?} */ (this._document.activeElement);
this.focusTrap.focusInitialElementWhenReady();
}
};
/**
* @return {?}
*/
CdkTrapFocus.prototype.ngDoCheck = /**
* @return {?}
*/
function () {
if (!this.focusTrap.hasAttached()) {
this.focusTrap.attachAnchors();
}
};
CdkTrapFocus.decorators = [
{ type: Directive, args: [{
selector: '[cdkTrapFocus]',
exportAs: 'cdkTrapFocus',
},] },
];
/** @nocollapse */
CdkTrapFocus.ctorParameters = function () { return [
{ type: ElementRef, },
{ type: FocusTrapFactory, },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] },] },
]; };
CdkTrapFocus.propDecorators = {
"enabled": [{ type: Input, args: ['cdkTrapFocus',] },],
"autoCapture": [{ type: Input, args: ['cdkTrapFocusAutoCapture',] },],
};
return CdkTrapFocus;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
// The token for the live announcer element is defined in a separate file from LiveAnnouncer
// as a workaround for https://github.com/angular/angular/issues/22559
var /** @type {?} */ LIVE_ANNOUNCER_ELEMENT_TOKEN = new InjectionToken('liveAnnouncerElement', {
providedIn: 'root',
factory: LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY,
});
/**
* \@docs-private
* @return {?}
*/
function LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY() {
return null;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var LiveAnnouncer = /** @class */ (function () {
function LiveAnnouncer(elementToken, _document) {
// We inject the live element and document as `any` because the constructor signature cannot
// reference browser globals (HTMLElement, Document) on non-browser environments, since having
// a class decorator causes TypeScript to preserve the constructor signature types.
this._document = _document;
this._liveElement = elementToken || this._createLiveElement();
}
/**
* Announces a message to screenreaders.
* @param message Message to be announced to the screenreader
* @param politeness The politeness of the announcer element
* @returns Promise that will be resolved when the message is added to the DOM.
*/
/**
* Announces a message to screenreaders.
* @param {?} message Message to be announced to the screenreader
* @param {?=} politeness The politeness of the announcer element
* @return {?} Promise that will be resolved when the message is added to the DOM.
*/
LiveAnnouncer.prototype.announce = /**
* Announces a message to screenreaders.
* @param {?} message Message to be announced to the screenreader
* @param {?=} politeness The politeness of the announcer element
* @return {?} Promise that will be resolved when the message is added to the DOM.
*/
function (message, politeness) {
var _this = this;
if (politeness === void 0) { politeness = 'polite'; }
this._liveElement.textContent = '';
// TODO: ensure changing the politeness works on all environments we support.
this._liveElement.setAttribute('aria-live', politeness);
// This 100ms timeout is necessary for some browser + screen-reader combinations:
// - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.
// - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a
// second time without clearing and then using a non-zero delay.
// (using JAWS 17 at time of this writing).
return new Promise(function (resolve) {
setTimeout(function () {
_this._liveElement.textContent = message;
resolve();
}, 100);
});
};
/**
* @return {?}
*/
LiveAnnouncer.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
if (this._liveElement && this._liveElement.parentNode) {
this._liveElement.parentNode.removeChild(this._liveElement);
}
};
/**
* @return {?}
*/
LiveAnnouncer.prototype._createLiveElement = /**
* @return {?}
*/
function () {
var /** @type {?} */ elementClass = 'cdk-live-announcer-element';
var /** @type {?} */ previousElements = this._document.getElementsByClassName(elementClass);
// Remove any old containers. This can happen when coming in from a server-side-rendered page.
for (var /** @type {?} */ i = 0; i < previousElements.length; i++) {
/** @type {?} */ ((previousElements[i].parentNode)).removeChild(previousElements[i]);
}
var /** @type {?} */ liveEl = this._document.createElement('div');
liveEl.classList.add(elementClass);
liveEl.classList.add('cdk-visually-hidden');
liveEl.setAttribute('aria-atomic', 'true');
liveEl.setAttribute('aria-live', 'polite');
this._document.body.appendChild(liveEl);
return liveEl;
};
LiveAnnouncer.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] },
];
/** @nocollapse */
LiveAnnouncer.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [LIVE_ANNOUNCER_ELEMENT_TOKEN,] },] },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] },] },
]; };
/** @nocollapse */ LiveAnnouncer.ngInjectableDef = defineInjectable({ factory: function LiveAnnouncer_Factory() { return new LiveAnnouncer(inject(LIVE_ANNOUNCER_ELEMENT_TOKEN, 8), inject(DOCUMENT)); }, token: LiveAnnouncer, providedIn: "root" });
return LiveAnnouncer;
}());
/**
* A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility
* with a wider range of browsers and screen readers.
*/
var CdkAriaLive = /** @class */ (function () {
function CdkAriaLive(_elementRef, _liveAnnouncer, _contentObserver, _ngZone) {
this._elementRef = _elementRef;
this._liveAnnouncer = _liveAnnouncer;
this._contentObserver = _contentObserver;
this._ngZone = _ngZone;
this._politeness = 'off';
}
Object.defineProperty(CdkAriaLive.prototype, "politeness", {
get: /**
* The aria-live politeness level to use when announcing messages.
* @return {?}
*/
function () { return this._politeness; },
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
var _this = this;
this._politeness = value === 'polite' || value === 'assertive' ? value : 'off';
if (this._politeness === 'off') {
if (this._subscription) {
this._subscription.unsubscribe();
this._subscription = null;
}
}
else if (!this._subscription) {
this._subscription = this._ngZone.runOutsideAngular(function () {
return _this._contentObserver
.observe(_this._elementRef)
.subscribe(function () {
// Note that we use textContent here, rather than innerText, in order to avoid a reflow.
var /** @type {?} */ element = _this._elementRef.nativeElement;
_this._liveAnnouncer.announce(element.textContent, _this._politeness);
});
});
}
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
CdkAriaLive.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
if (this._subscription) {
this._subscription.unsubscribe();
}
};
CdkAriaLive.decorators = [
{ type: Directive, args: [{
selector: '[cdkAriaLive]',
exportAs: 'cdkAriaLive',
},] },
];
/** @nocollapse */
CdkAriaLive.ctorParameters = function () { return [
{ type: ElementRef, },
{ type: LiveAnnouncer, },
{ type: ContentObserver, },
{ type: NgZone, },
]; };
CdkAriaLive.propDecorators = {
"politeness": [{ type: Input, args: ['cdkAriaLive',] },],
};
return CdkAriaLive;
}());
/**
* \@docs-private \@deprecated \@breaking-change 7.0.0
* @param {?} parentDispatcher
* @param {?} liveElement
* @param {?} _document
* @return {?}
*/
function LIVE_ANNOUNCER_PROVIDER_FACTORY(parentDispatcher, liveElement, _document) {
return parentDispatcher || new LiveAnnouncer(liveElement, _document);
}
/**
* \@docs-private \@deprecated \@breaking-change 7.0.0
*/
var /** @type {?} */ LIVE_ANNOUNCER_PROVIDER = {
// If there is already a LiveAnnouncer available, use that. Otherwise, provide a new one.
provide: LiveAnnouncer,
deps: [
[new Optional(), new SkipSelf(), LiveAnnouncer],
[new Optional(), new Inject(LIVE_ANNOUNCER_ELEMENT_TOKEN)],
DOCUMENT,
],
useFactory: LIVE_ANNOUNCER_PROVIDER_FACTORY
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
// This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
// that a value of around 650ms seems appropriate.
var /** @type {?} */ TOUCH_BUFFER_MS = 650;
/**
* Monitors mouse and keyboard events to determine the cause of focus events.
*/
var FocusMonitor = /** @class */ (function () {
function FocusMonitor(_ngZone, _platform) {
this._ngZone = _ngZone;
this._platform = _platform;
/**
* The focus origin that the next focus event is a result of.
*/
this._origin = null;
/**
* Whether the window has just been focused.
*/
this._windowFocused = false;
/**
* Map of elements being monitored to their info.
*/
this._elementInfo = new Map();
/**
* A map of global objects to lists of current listeners.
*/
this._unregisterGlobalListeners = function () { };
/**
* The number of elements currently being monitored.
*/
this._monitoredElementCount = 0;
}
/**
* Monitors focus on an element and applies appropriate CSS classes.
* @param element The element to monitor
* @param checkChildren Whether to count the element as focused when its children are focused.
* @returns An observable that emits when the focus state of the element changes.
* When the element is blurred, null will be emitted.
*/
/**
* Monitors focus on an element and applies appropriate CSS classes.
* @param {?} element The element to monitor
* @param {?=} checkChildren Whether to count the element as focused when its children are focused.
* @return {?} An observable that emits when the focus state of the element changes.
* When the element is blurred, null will be emitted.
*/
FocusMonitor.prototype.monitor = /**
* Monitors focus on an element and applies appropriate CSS classes.
* @param {?} element The element to monitor
* @param {?=} checkChildren Whether to count the element as focused when its children are focused.
* @return {?} An observable that emits when the focus state of the element changes.
* When the element is blurred, null will be emitted.
*/
function (element, checkChildren) {
var _this = this;
if (checkChildren === void 0) { checkChildren = false; }
// Do nothing if we're not on the browser platform.
if (!this._platform.isBrowser) {
return of(null);
}
// Check if we're already monitoring this element.
if (this._elementInfo.has(element)) {
var /** @type {?} */ cachedInfo = this._elementInfo.get(element); /** @type {?} */
((cachedInfo)).checkChildren = checkChildren;
return /** @type {?} */ ((cachedInfo)).subject.asObservable();
}
// Create monitored element info.
var /** @type {?} */ info = {
unlisten: function () { },
checkChildren: checkChildren,
subject: new Subject()
};
this._elementInfo.set(element, info);
this._incrementMonitoredElementCount();
// Start listening. We need to listen in capture phase since focus events don't bubble.
var /** @type {?} */ focusListener = function (event) { return _this._onFocus(event, element); };
var /** @type {?} */ blurListener = function (event) { return _this._onBlur(event, element); };
this._ngZone.runOutsideAngular(function () {
element.addEventListener('focus', focusListener, true);
element.addEventListener('blur', blurListener, true);
});
// Create an unlisten function for later.
info.unlisten = function () {
element.removeEventListener('focus', focusListener, true);
element.removeEventListener('blur', blurListener, true);
};
return info.subject.asObservable();
};
/**
* Stops monitoring an element and removes all focus classes.
* @param element The element to stop monitoring.
*/
/**
* Stops monitoring an element and removes all focus classes.
* @param {?} element The element to stop monitoring.
* @return {?}
*/
FocusMonitor.prototype.stopMonitoring = /**
* Stops monitoring an element and removes all focus classes.
* @param {?} element The element to stop monitoring.
* @return {?}
*/
function (element) {
var /** @type {?} */ elementInfo = this._elementInfo.get(element);
if (elementInfo) {
elementInfo.unlisten();
elementInfo.subject.complete();
this._setClasses(element);
this._elementInfo.delete(element);
this._decrementMonitoredElementCount();
}
};
/**
* Focuses the element via the specified focus origin.
* @param element Element to focus.
* @param origin Focus origin.
* @param options Options that can be used to configure the focus behavior.
*/
/**
* Focuses the element via the specified focus origin.
* @param {?} element Element to focus.
* @param {?} origin Focus origin.
* @param {?=} options Options that can be used to configure the focus behavior.
* @return {?}
*/
FocusMonitor.prototype.focusVia = /**
* Focuses the element via the specified focus origin.
* @param {?} element Element to focus.
* @param {?} origin Focus origin.
* @param {?=} options Options that can be used to configure the focus behavior.
* @return {?}
*/
function (element, origin, options) {
this._setOriginForCurrentEventQueue(origin);
// `focus` isn't available on the server
if (typeof element.focus === 'function') {
// Cast the element to `any`, because the TS typings don't have the `options` parameter yet.
(/** @type {?} */ (element)).focus(options);
}
};
/**
* @return {?}
*/
FocusMonitor.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
var _this = this;
this._elementInfo.forEach(function (_info, element) { return _this.stopMonitoring(element); });
};
/**
* Register necessary event listeners on the document and window.
* @return {?}
*/
FocusMonitor.prototype._registerGlobalListeners = /**
* Register necessary event listeners on the document and window.
* @return {?}
*/
function () {
var _this = this;
// Do nothing if we're not on the browser platform.
if (!this._platform.isBrowser) {
return;
}
// On keydown record the origin and clear any touch event that may be in progress.
var /** @type {?} */ documentKeydownListener = function () {
_this._lastTouchTarget = null;
_this._setOriginForCurrentEventQueue('keyboard');
};
// On mousedown record the origin only if there is not touch target, since a mousedown can
// happen as a result of a touch event.
var /** @type {?} */ documentMousedownListener = function () {
if (!_this._lastTouchTarget) {
_this._setOriginForCurrentEventQueue('mouse');
}
};
// When the touchstart event fires the focus event is not yet in the event queue. This means
// we can't rely on the trick used above (setting timeout of 1ms). Instead we wait 650ms to
// see if a focus happens.
var /** @type {?} */ documentTouchstartListener = function (event) {
if (_this._touchTimeoutId != null) {
clearTimeout(_this._touchTimeoutId);
}
_this._lastTouchTarget = event.target;
_this._touchTimeoutId = setTimeout(function () { return _this._lastTouchTarget = null; }, TOUCH_BUFFER_MS);
};
// Make a note of when the window regains focus, so we can restore the origin info for the
// focused element.
var /** @type {?} */ windowFocusListener = function () {
_this._windowFocused = true;
_this._windowFocusTimeoutId = setTimeout(function () { return _this._windowFocused = false; });
};
// Note: we listen to events in the capture phase so we can detect them even if the user stops
// propagation.
this._ngZone.runOutsideAngular(function () {
document.addEventListener('keydown', documentKeydownListener, true);
document.addEventListener('mousedown', documentMousedownListener, true);
document.addEventListener('touchstart', documentTouchstartListener, supportsPassiveEventListeners() ? (/** @type {?} */ ({ passive: true, capture: true })) : true);
window.addEventListener('focus', windowFocusListener);
});
this._unregisterGlobalListeners = function () {
document.removeEventListener('keydown', documentKeydownListener, true);
document.removeEventListener('mousedown', documentMousedownListener, true);
document.removeEventListener('touchstart', documentTouchstartListener, supportsPassiveEventListeners() ? (/** @type {?} */ ({ passive: true, capture: true })) : true);
window.removeEventListener('focus', windowFocusListener);
// Clear timeouts for all potentially pending timeouts to prevent the leaks.
clearTimeout(_this._windowFocusTimeoutId);
clearTimeout(_this._touchTimeoutId);
clearTimeout(_this._originTimeoutId);
};
};
/**
* @param {?} element
* @param {?} className
* @param {?} shouldSet
* @return {?}
*/
FocusMonitor.prototype._toggleClass = /**
* @param {?} element
* @param {?} className
* @param {?} shouldSet
* @return {?}
*/
function (element, className, shouldSet) {
if (shouldSet) {
element.classList.add(className);
}
else {
element.classList.remove(className);
}
};
/**
* Sets the focus classes on the element based on the given focus origin.
* @param {?} element The element to update the classes on.
* @param {?=} origin The focus origin.
* @return {?}
*/
FocusMonitor.prototype._setClasses = /**
* Sets the focus classes on the element based on the given focus origin.
* @param {?} element The element to update the classes on.
* @param {?=} origin The focus origin.
* @return {?}
*/
function (element, origin) {
var /** @type {?} */ elementInfo = this._elementInfo.get(element);
if (elementInfo) {
this._toggleClass(element, 'cdk-focused', !!origin);
this._toggleClass(element, 'cdk-touch-focused', origin === 'touch');
this._toggleClass(element, 'cdk-keyboard-focused', origin === 'keyboard');
this._toggleClass(element, 'cdk-mouse-focused', origin === 'mouse');
this._toggleClass(element, 'cdk-program-focused', origin === 'program');
}
};
/**
* Sets the origin and schedules an async function to clear it at the end of the event queue.
* @param {?} origin The origin to set.
* @return {?}
*/
FocusMonitor.prototype._setOriginForCurrentEventQueue = /**
* Sets the origin and schedules an async function to clear it at the end of the event queue.
* @param {?} origin The origin to set.
* @return {?}
*/
function (origin) {
var _this = this;
this._ngZone.runOutsideAngular(function () {
_this._origin = origin;
// Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*
// tick after the interaction event fired. To ensure the focus origin is always correct,
// the focus origin will be determined at the beginning of the next tick.
// Sometimes the focus origin won't be valid in Firefox because Firefox seems to focus *one*
// tick after the interaction event fired. To ensure the focus origin is always correct,
// the focus origin will be determined at the beginning of the next tick.
_this._originTimeoutId = setTimeout(function () { return _this._origin = null; }, 1);
});
};
/**
* Checks whether the given focus event was caused by a touchstart event.
* @param {?} event The focus event to check.
* @return {?} Whether the event was caused by a touch.
*/
FocusMonitor.prototype._wasCausedByTouch = /**
* Checks whether the given focus event was caused by a touchstart event.
* @param {?} event The focus event to check.
* @return {?} Whether the event was caused by a touch.
*/
function (event) {
// Note(mmalerba): This implementation is not quite perfect, there is a small edge case.
// Consider the following dom structure:
//
// <div #parent tabindex="0" cdkFocusClasses>
// <div #child (click)="#parent.focus()"></div>
// </div>
//
// If the user touches the #child element and the #parent is programmatically focused as a
// result, this code will still consider it to have been caused by the touch event and will
// apply the cdk-touch-focused class rather than the cdk-program-focused class. This is a
// relatively small edge-case that can be worked around by using
// focusVia(parentEl, 'program') to focus the parent element.
//
// If we decide that we absolutely must handle this case correctly, we can do so by listening
// for the first focus event after the touchstart, and then the first blur event after that
// focus event. When that blur event fires we know that whatever follows is not a result of the
// touchstart.
var /** @type {?} */ focusTarget = event.target;
return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
(focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
};
/**
* Handles focus events on a registered element.
* @param {?} event The focus event.
* @param {?} element The monitored element.
* @return {?}
*/
FocusMonitor.prototype._onFocus = /**
* Handles focus events on a registered element.
* @param {?} event The focus event.
* @param {?} element The monitored element.
* @return {?}
*/
function (event, element) {
// NOTE(mmalerba): We currently set the classes based on the focus origin of the most recent
// focus event affecting the monitored element. If we want to use the origin of the first event
// instead we should check for the cdk-focused class here and return if the element already has
// it. (This only matters for elements that have includesChildren = true).
// If we are not counting child-element-focus as focused, make sure that the event target is the
// monitored element itself.
var /** @type {?} */ elementInfo = this._elementInfo.get(element);
if (!elementInfo || (!elementInfo.checkChildren && element !== event.target)) {
return;
}
// If we couldn't detect a cause for the focus event, it's due to one of three reasons:
// 1) The window has just regained focus, in which case we want to restore the focused state of
// the element from before the window blurred.
// 2) It was caused by a touch event, in which case we mark the origin as 'touch'.
// 3) The element was programmatically focused, in which case we should mark the origin as
// 'program'.
var /** @type {?} */ origin = this._origin;
if (!origin) {
if (this._windowFocused && this._lastFocusOrigin) {
origin = this._lastFocusOrigin;
}
else if (this._wasCausedByTouch(event)) {
origin = 'touch';
}
else {
origin = 'program';
}
}
this._setClasses(element, origin);
this._emitOrigin(elementInfo.subject, origin);
this._lastFocusOrigin = origin;
};
/**
* Handles blur events on a registered element.
* @param event The blur event.
* @param element The monitored element.
*/
/**
* Handles blur events on a registered element.
* @param {?} event The blur event.
* @param {?} element The monitored element.
* @return {?}
*/
FocusMonitor.prototype._onBlur = /**
* Handles blur events on a registered element.
* @param {?} event The blur event.
* @param {?} element The monitored element.
* @return {?}
*/
function (event, element) {
// If we are counting child-element-focus as focused, make sure that we aren't just blurring in
// order to focus another child of the monitored element.
var /** @type {?} */ elementInfo = this._elementInfo.get(element);
if (!elementInfo || (elementInfo.checkChildren && event.relatedTarget instanceof Node &&
element.contains(event.relatedTarget))) {
return;
}
this._setClasses(element);
this._emitOrigin(elementInfo.subject, null);
};
/**
* @param {?} subject
* @param {?} origin
* @return {?}
*/
FocusMonitor.prototype._emitOrigin = /**
* @param {?} subject
* @param {?} origin
* @return {?}
*/
function (subject, origin) {
this._ngZone.run(function () { return subject.next(origin); });
};
/**
* @return {?}
*/
FocusMonitor.prototype._incrementMonitoredElementCount = /**
* @return {?}
*/
function () {
// Register global listeners when first element is monitored.
if (++this._monitoredElementCount == 1) {
this._registerGlobalListeners();
}
};
/**
* @return {?}
*/
FocusMonitor.prototype._decrementMonitoredElementCount = /**
* @return {?}
*/
function () {
// Unregister global listeners when last element is unmonitored.
if (!--this._monitoredElementCount) {
this._unregisterGlobalListeners();
this._unregisterGlobalListeners = function () { };
}
};
FocusMonitor.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] },
];
/** @nocollapse */
FocusMonitor.ctorParameters = function () { return [
{ type: NgZone, },
{ type: Platform, },
]; };
/** @nocollapse */ FocusMonitor.ngInjectableDef = defineInjectable({ factory: function FocusMonitor_Factory() { return new FocusMonitor(inject(NgZone), inject(Platform)); }, token: FocusMonitor, providedIn: "root" });
return FocusMonitor;
}());
/**
* Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
* programmatically) and adds corresponding classes to the element.
*
* There are two variants of this directive:
* 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is
* focused.
* 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused.
*/
var CdkMonitorFocus = /** @class */ (function () {
function CdkMonitorFocus(_elementRef, _focusMonitor) {
var _this = this;
this._elementRef = _elementRef;
this._focusMonitor = _focusMonitor;
this.cdkFocusChange = new EventEmitter();
this._monitorSubscription = this._focusMonitor.monitor(this._elementRef.nativeElement, this._elementRef.nativeElement.hasAttribute('cdkMonitorSubtreeFocus'))
.subscribe(function (origin) { return _this.cdkFocusChange.emit(origin); });
}
/**
* @return {?}
*/
CdkMonitorFocus.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);
this._monitorSubscription.unsubscribe();
};
CdkMonitorFocus.decorators = [
{ type: Directive, args: [{
selector: '[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]',
},] },
];
/** @nocollapse */
CdkMonitorFocus.ctorParameters = function () { return [
{ type: ElementRef, },
{ type: FocusMonitor, },
]; };
CdkMonitorFocus.propDecorators = {
"cdkFocusChange": [{ type: Output },],
};
return CdkMonitorFocus;
}());
/**
* \@docs-private \@deprecated \@breaking-change 7.0.0
* @param {?} parentDispatcher
* @param {?} ngZone
* @param {?} platform
* @return {?}
*/
function FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) {
return parentDispatcher || new FocusMonitor(ngZone, platform);
}
/**
* \@docs-private \@deprecated \@breaking-change 7.0.0
*/
var /** @type {?} */ FOCUS_MONITOR_PROVIDER = {
// If there is already a FocusMonitor available, use that. Otherwise, provide a new one.
provide: FocusMonitor,
deps: [[new Optional(), new SkipSelf(), FocusMonitor], NgZone, Platform],
useFactory: FOCUS_MONITOR_PROVIDER_FACTORY
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* Screenreaders will often fire fake mousedown events when a focusable element
* is activated using the keyboard. We can typically distinguish between these faked
* mousedown events and real mousedown events using the "buttons" property. While
* real mousedowns will indicate the mouse button that was pressed (e.g. "1" for
* the left mouse button), faked mousedowns will usually set the property value to 0.
* @param {?} event
* @return {?}
*/
function isFakeMousedownFromScreenReader(event) {
return event.buttons === 0;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var A11yModule = /** @class */ (function () {
function A11yModule() {
}
A11yModule.decorators = [
{ type: NgModule, args: [{
imports: [CommonModule, PlatformModule, ObserversModule],
declarations: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
},] },
];
return A11yModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
export { MESSAGES_CONTAINER_ID, CDK_DESCRIBEDBY_ID_PREFIX, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, AriaDescriber, ARIA_DESCRIBER_PROVIDER_FACTORY, ARIA_DESCRIBER_PROVIDER, ActiveDescendantKeyManager, FocusKeyManager, ListKeyManager, FocusTrap, FocusTrapFactory, CdkTrapFocus, InteractivityChecker, LiveAnnouncer, CdkAriaLive, LIVE_ANNOUNCER_PROVIDER_FACTORY, LIVE_ANNOUNCER_PROVIDER, LIVE_ANNOUNCER_ELEMENT_TOKEN, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY, TOUCH_BUFFER_MS, FocusMonitor, CdkMonitorFocus, FOCUS_MONITOR_PROVIDER_FACTORY, FOCUS_MONITOR_PROVIDER, isFakeMousedownFromScreenReader, A11yModule };
//# sourceMappingURL=a11y.es5.js.map