@angular/cdk 9.2.0 → 9.2.4

package/fesm2015/a11y.js

@@ -4,7 +4,7 @@ import { Subject, Subscription, of } from 'rxjs';
 import { hasModifierKey, A, Z, ZERO, NINE, LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, TAB } from '@angular/cdk/keycodes';
 import { tap, debounceTime, filter, map, take } from 'rxjs/operators';
 import { coerceBooleanProperty, coerceElement } from '@angular/cdk/coercion';
-import { Platform, normalizePassiveListenerOptions, PlatformModule } from '@angular/cdk/platform';
+import { Platform, normalizePassiveListenerOptions, _getShadowRoot, PlatformModule } from '@angular/cdk/platform';
 import { ContentObserver, ObserversModule } from '@angular/cdk/observers';
 
 /**
@@ -20,10 +20,10 @@ import { ContentObserver, ObserversModule } from '@angular/cdk/observers';
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * IDs are deliminated by an empty space, as per the spec.
+ * IDs are delimited by an empty space, as per the spec.
  * @type {?}
  */
-const ID_DELIMINATOR = ' ';
+const ID_DELIMITER = ' ';
 /**
  * Adds the given ID to the specified ARIA attribute on an element.
  * Used for attributes such as aria-labelledby, aria-owns, etc.
@@ -43,7 +43,7 @@ function addAriaReferencedId(el, attr, id) {
         return;
     }
     ids.push(id.trim());
-    el.setAttribute(attr, ids.join(ID_DELIMINATOR));
+    el.setAttribute(attr, ids.join(ID_DELIMITER));
 }
 /**
  * Removes the given ID from the specified ARIA attribute on an element.
@@ -63,7 +63,7 @@ function removeAriaReferencedId(el, attr, id) {
      */
     val => val != id.trim()));
     if (filteredIds.length) {
-        el.setAttribute(attr, filteredIds.join(ID_DELIMINATOR));
+        el.setAttribute(attr, filteredIds.join(ID_DELIMITER));
     }
     else {
         el.removeAttribute(attr);
@@ -77,7 +77,7 @@ function removeAriaReferencedId(el, attr, id) {
  * @return {?}
  */
 function getAriaReferenceIds(el, attr) {
-    // Get string array of all individual ids (whitespace deliminated) in the attribute value
+    // Get string array of all individual ids (whitespace delimited) in the attribute value
     return (el.getAttribute(attr) || '').match(/\S+/g) || [];
 }
 
@@ -2653,6 +2653,31 @@ if (false) {
     CdkAriaLive.prototype._ngZone;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * Generated from: src/cdk/a11y/fake-mousedown.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * 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
  * Generated from: src/cdk/a11y/focus-monitor/focus-monitor.ts
@@ -2743,6 +2768,13 @@ class FocusMonitor {
          * The number of elements currently being monitored.
          */
         this._monitoredElementCount = 0;
+        /**
+         * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
+         * as well as the number of monitored elements that they contain. We have to treat focus/blur
+         * handlers differently from the rest of the events, because the browser won't emit events
+         * to the document when focus moves inside of a shadow root.
+         */
+        this._rootNodeFocusListenerCount = new Map();
         /**
          * Event listener for `keydown` events on the document.
          * Needs to be an arrow function in order to preserve the context when it gets bound.
@@ -2760,13 +2792,18 @@ class FocusMonitor {
          * Needs to be an arrow function in order to preserve the context when it gets bound.
          */
         this._documentMousedownListener = (/**
+         * @param {?} event
          * @return {?}
          */
-        () => {
+        (event) => {
             // On mousedown record the origin only if there is not touch
             // target, since a mousedown can happen as a result of a touch event.
             if (!this._lastTouchTarget) {
-                this._setOriginForCurrentEventQueue('mouse');
+                // In some cases screen readers fire fake `mousedown` events instead of `keydown`.
+                // Resolve the focus source to `keyboard` if we detect one of them.
+                /** @type {?} */
+                const source = isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse';
+                this._setOriginForCurrentEventQueue(source);
             }
         });
         /**
@@ -2784,10 +2821,7 @@ class FocusMonitor {
             if (this._touchTimeoutId != null) {
                 clearTimeout(this._touchTimeoutId);
             }
-            // Since this listener is bound on the `document` level, any events coming from the shadow DOM
-            // will have their `target` set to the shadow root. If available, use `composedPath` to
-            // figure out the event target.
-            this._lastTouchTarget = event.composedPath ? event.composedPath()[0] : event.target;
+            this._lastTouchTarget = getTarget(event);
             this._touchTimeoutId = setTimeout((/**
              * @return {?}
              */
@@ -2809,6 +2843,24 @@ class FocusMonitor {
              */
             () => this._windowFocused = false));
         });
+        /**
+         * Event listener for `focus` and 'blur' events on the document.
+         * Needs to be an arrow function in order to preserve the context when it gets bound.
+         */
+        this._rootNodeFocusAndBlurListener = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        (event) => {
+            /** @type {?} */
+            const target = getTarget(event);
+            /** @type {?} */
+            const handler = event.type === 'focus' ? this._onFocus : this._onBlur;
+            // We need to walk up the ancestor chain in order to support `checkChildren`.
+            for (let element = target; element; element = element.parentElement) {
+                handler.call(this, (/** @type {?} */ (event)), element);
+            }
+        });
         this._document = document;
         this._detectionMode = (options === null || options === void 0 ? void 0 : options.detectionMode) || 0 /* IMMEDIATE */;
     }
@@ -2824,53 +2876,32 @@ class FocusMonitor {
         }
         /** @type {?} */
         const nativeElement = coerceElement(element);
+        // If the element is inside the shadow DOM, we need to bind our focus/blur listeners to
+        // the shadow root, rather than the `document`, because the browser won't emit focus events
+        // to the `document`, if focus is moving within the same shadow root.
+        /** @type {?} */
+        const rootNode = ((/** @type {?} */ (_getShadowRoot(nativeElement)))) || this._getDocument();
+        /** @type {?} */
+        const cachedInfo = this._elementInfo.get(nativeElement);
         // Check if we're already monitoring this element.
-        if (this._elementInfo.has(nativeElement)) {
-            /** @type {?} */
-            let cachedInfo = this._elementInfo.get(nativeElement);
-            (/** @type {?} */ (cachedInfo)).checkChildren = checkChildren;
-            return (/** @type {?} */ (cachedInfo)).subject.asObservable();
+        if (cachedInfo) {
+            if (checkChildren) {
+                // TODO(COMP-318): this can be problematic, because it'll turn all non-checkChildren
+                // observers into ones that behave as if `checkChildren` was turned on. We need a more
+                // robust solution.
+                cachedInfo.checkChildren = true;
+            }
+            return cachedInfo.subject.asObservable();
         }
         // Create monitored element info.
         /** @type {?} */
-        let info = {
-            unlisten: (/**
-             * @return {?}
-             */
-            () => { }),
+        const info = {
             checkChildren: checkChildren,
-            subject: new Subject()
+            subject: new Subject(),
+            rootNode
         };
         this._elementInfo.set(nativeElement, info);
-        this._incrementMonitoredElementCount();
-        // Start listening. We need to listen in capture phase since focus events don't bubble.
-        /** @type {?} */
-        let focusListener = (/**
-         * @param {?} event
-         * @return {?}
-         */
-        (event) => this._onFocus(event, nativeElement));
-        /** @type {?} */
-        let blurListener = (/**
-         * @param {?} event
-         * @return {?}
-         */
-        (event) => this._onBlur(event, nativeElement));
-        this._ngZone.runOutsideAngular((/**
-         * @return {?}
-         */
-        () => {
-            nativeElement.addEventListener('focus', focusListener, true);
-            nativeElement.addEventListener('blur', blurListener, true);
-        }));
-        // Create an unlisten function for later.
-        info.unlisten = (/**
-         * @return {?}
-         */
-        () => {
-            nativeElement.removeEventListener('focus', focusListener, true);
-            nativeElement.removeEventListener('blur', blurListener, true);
-        });
+        this._registerGlobalListeners(info);
         return info.subject.asObservable();
     }
     /**
@@ -2883,11 +2914,10 @@ class FocusMonitor {
         /** @type {?} */
         const elementInfo = this._elementInfo.get(nativeElement);
         if (elementInfo) {
-            elementInfo.unlisten();
             elementInfo.subject.complete();
             this._setClasses(nativeElement);
             this._elementInfo.delete(nativeElement);
-            this._decrementMonitoredElementCount();
+            this._removeGlobalListeners(elementInfo);
         }
     }
     /**
@@ -2950,6 +2980,31 @@ class FocusMonitor {
             element.classList.remove(className);
         }
     }
+    /**
+     * @private
+     * @param {?} event
+     * @return {?}
+     */
+    _getFocusOrigin(event) {
+        // 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'.
+        if (this._origin) {
+            return this._origin;
+        }
+        if (this._windowFocused && this._lastFocusOrigin) {
+            return this._lastFocusOrigin;
+        }
+        else if (this._wasCausedByTouch(event)) {
+            return 'touch';
+        }
+        else {
+            return 'program';
+        }
+    }
     /**
      * Sets the focus classes on the element based on the given focus origin.
      * @private
@@ -2958,15 +3013,11 @@ class FocusMonitor {
      * @return {?}
      */
     _setClasses(element, origin) {
-        /** @type {?} */
-        const 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');
-        }
+        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.
@@ -3017,7 +3068,7 @@ class FocusMonitor {
         // focus event. When that blur event fires we know that whatever follows is not a result of the
         // touchstart.
         /** @type {?} */
-        let focusTarget = event.target;
+        const focusTarget = getTarget(event);
         return this._lastTouchTarget instanceof Node && focusTarget instanceof Node &&
             (focusTarget === this._lastTouchTarget || focusTarget.contains(this._lastTouchTarget));
     }
@@ -3041,28 +3092,11 @@ class FocusMonitor {
         // monitored element itself.
         /** @type {?} */
         const elementInfo = this._elementInfo.get(element);
-        if (!elementInfo || (!elementInfo.checkChildren && element !== event.target)) {
+        if (!elementInfo || (!elementInfo.checkChildren && element !== getTarget(event))) {
             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'.
         /** @type {?} */
-        let origin = this._origin;
-        if (!origin) {
-            if (this._windowFocused && this._lastFocusOrigin) {
-                origin = this._lastFocusOrigin;
-            }
-            else if (this._wasCausedByTouch(event)) {
-                origin = 'touch';
-            }
-            else {
-                origin = 'program';
-            }
-        }
+        const origin = this._getFocusOrigin(event);
         this._setClasses(element, origin);
         this._emitOrigin(elementInfo.subject, origin);
         this._lastFocusOrigin = origin;
@@ -3099,11 +3133,29 @@ class FocusMonitor {
     }
     /**
      * @private
+     * @param {?} elementInfo
      * @return {?}
      */
-    _incrementMonitoredElementCount() {
+    _registerGlobalListeners(elementInfo) {
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        /** @type {?} */
+        const rootNode = elementInfo.rootNode;
+        /** @type {?} */
+        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+        if (!rootNodeFocusListeners) {
+            this._ngZone.runOutsideAngular((/**
+             * @return {?}
+             */
+            () => {
+                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+            }));
+        }
+        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
         // Register global listeners when first element is monitored.
-        if (++this._monitoredElementCount == 1 && this._platform.isBrowser) {
+        if (++this._monitoredElementCount === 1) {
             // Note: we listen to events in the capture phase so we
             // can detect them even if the user stops propagation.
             this._ngZone.runOutsideAngular((/**
@@ -3123,9 +3175,24 @@ class FocusMonitor {
     }
     /**
      * @private
+     * @param {?} elementInfo
      * @return {?}
      */
-    _decrementMonitoredElementCount() {
+    _removeGlobalListeners(elementInfo) {
+        /** @type {?} */
+        const rootNode = elementInfo.rootNode;
+        if (this._rootNodeFocusListenerCount.has(rootNode)) {
+            /** @type {?} */
+            const rootNodeFocusListeners = (/** @type {?} */ (this._rootNodeFocusListenerCount.get(rootNode)));
+            if (rootNodeFocusListeners > 1) {
+                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
+            }
+            else {
+                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                this._rootNodeFocusListenerCount.delete(rootNode);
+            }
+        }
         // Unregister global listeners when last element is unmonitored.
         if (!--this._monitoredElementCount) {
             /** @type {?} */
@@ -3209,6 +3276,15 @@ if (false) {
      * @private
      */
     FocusMonitor.prototype._monitoredElementCount;
+    /**
+     * Keeps track of the root nodes to which we've currently bound a focus/blur handler,
+     * as well as the number of monitored elements that they contain. We have to treat focus/blur
+     * handlers differently from the rest of the events, because the browser won't emit events
+     * to the document when focus moves inside of a shadow root.
+     * @type {?}
+     * @private
+     */
+    FocusMonitor.prototype._rootNodeFocusListenerCount;
     /**
      * The specified detection mode, used for attributing the origin of a focus
      * event.
@@ -3250,6 +3326,13 @@ if (false) {
      * @protected
      */
     FocusMonitor.prototype._document;
+    /**
+     * Event listener for `focus` and 'blur' events on the document.
+     * Needs to be an arrow function in order to preserve the context when it gets bound.
+     * @type {?}
+     * @private
+     */
+    FocusMonitor.prototype._rootNodeFocusAndBlurListener;
     /**
      * @type {?}
      * @private
@@ -3261,6 +3344,16 @@ if (false) {
      */
     FocusMonitor.prototype._platform;
 }
+/**
+ * Gets the target of an event, accounting for Shadow DOM.
+ * @param {?} event
+ * @return {?}
+ */
+function getTarget(event) {
+    // If an event is bound outside the Shadow DOM, the `event.target` will
+    // point to the shadow root so we have to use `composedPath` instead.
+    return (/** @type {?} */ ((event.composedPath ? event.composedPath()[0] : event.target)));
+}
 /**
  * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or
  * programmatically) and adds corresponding classes to the element.
@@ -3327,31 +3420,6 @@ if (false) {
     CdkMonitorFocus.prototype._focusMonitor;
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: src/cdk/a11y/fake-mousedown.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/**
- * 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
  * Generated from: src/cdk/a11y/high-contrast-mode/high-contrast-mode-detector.ts
@@ -3379,7 +3447,7 @@ const WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';
  */
 const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';
 /**
- * Service to determine whether the browser is currently in a high-constrast-mode environment.
+ * Service to determine whether the browser is currently in a high-contrast-mode environment.
  *
  * Microsoft Windows supports an accessibility feature called "High Contrast Mode". This mode
  * changes the appearance of all applications, including web applications, to dramatically increase
@@ -3399,7 +3467,7 @@ class HighContrastModeDetector {
         this._document = document;
     }
     /**
-     * Gets the current high-constrast-mode for the page.
+     * Gets the current high-contrast-mode for the page.
      * @return {?}
      */
     getHighContrastMode() {
@@ -3416,11 +3484,15 @@ class HighContrastModeDetector {
         this._document.body.appendChild(testElement);
         // Get the computed style for the background color, collapsing spaces to normalize between
         // browsers. Once we get this color, we no longer need the test element. Access the `window`
-        // via the document so we can fake it in tests.
+        // via the document so we can fake it in tests. Note that we have extra null checks, because
+        // this logic will likely run during app bootstrap and throwing can break the entire app.
+        /** @type {?} */
+        const documentWindow = this._document.defaultView || window;
         /** @type {?} */
-        const documentWindow = (/** @type {?} */ (this._document.defaultView));
+        const computedStyle = (documentWindow && documentWindow.getComputedStyle) ?
+            documentWindow.getComputedStyle(testElement) : null;
         /** @type {?} */
-        const computedColor = (documentWindow.getComputedStyle(testElement).backgroundColor || '').replace(/ /g, '');
+        const computedColor = (computedStyle && computedStyle.backgroundColor || '').replace(/ /g, '');
         this._document.body.removeChild(testElement);
         switch (computedColor) {
             case 'rgb(0,0,0)': return 2 /* WHITE_ON_BLACK */;