@angular/cdk 8.0.0-beta.2 → 8.0.0

package/bundles/cdk-overlay.umd.js

@@ -53,7 +53,7 @@ var __assign = function() {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Strategy that will prevent the user from scrolling while the overlay is visible.
@@ -166,7 +166,7 @@ BlockScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.
@@ -178,7 +178,7 @@ function getMatScrollStrategyAlreadyAttachedError() {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Strategy that will close the overlay as soon as the user starts scrolling.
@@ -197,12 +197,18 @@ CloseScrollStrategy = /** @class */ (function () {
         /**
          * Detaches the overlay ref and disables the scroll strategy.
          */
-        this._detach = function () {
+        this._detach = (/**
+         * @return {?}
+         */
+        function () {
             _this.disable();
             if (_this._overlayRef.hasAttached()) {
-                _this._ngZone.run(function () { return _this._overlayRef.detach(); });
+                _this._ngZone.run((/**
+                 * @return {?}
+                 */
+                function () { return _this._overlayRef.detach(); }));
             }
-        };
+        });
     }
     /** Attaches this scroll strategy to an overlay. */
     /**
@@ -239,7 +245,10 @@ CloseScrollStrategy = /** @class */ (function () {
         var stream = this._scrollDispatcher.scrolled(0);
         if (this._config && this._config.threshold && this._config.threshold > 1) {
             this._initialScrollPosition = this._viewportRuler.getViewportScrollPosition().top;
-            this._scrollSubscription = stream.subscribe(function () {
+            this._scrollSubscription = stream.subscribe((/**
+             * @return {?}
+             */
+            function () {
                 /** @type {?} */
                 var scrollPosition = _this._viewportRuler.getViewportScrollPosition().top;
                 if (Math.abs(scrollPosition - _this._initialScrollPosition) > (/** @type {?} */ ((/** @type {?} */ (_this._config)).threshold))) {
@@ -248,7 +257,7 @@ CloseScrollStrategy = /** @class */ (function () {
                 else {
                     _this._overlayRef.updatePosition();
                 }
-            });
+            }));
         }
         else {
             this._scrollSubscription = stream.subscribe(this._detach);
@@ -284,7 +293,7 @@ CloseScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
@@ -331,7 +340,7 @@ NoopScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 // TODO(jelbourn): move this to live with the rest of the scrolling code
@@ -344,7 +353,11 @@ NoopScrollStrategy = /** @class */ (function () {
  * @return {?} Whether the element is scrolled out of view
  */
 function isElementScrolledOutsideView(element, scrollContainers) {
-    return scrollContainers.some(function (containerBounds) {
+    return scrollContainers.some((/**
+     * @param {?} containerBounds
+     * @return {?}
+     */
+    function (containerBounds) {
         /** @type {?} */
         var outsideAbove = element.bottom < containerBounds.top;
         /** @type {?} */
@@ -354,7 +367,7 @@ function isElementScrolledOutsideView(element, scrollContainers) {
         /** @type {?} */
         var outsideRight = element.left > containerBounds.right;
         return outsideAbove || outsideBelow || outsideLeft || outsideRight;
-    });
+    }));
 }
 /**
  * Gets whether an element is clipped by any of its scrolling containers.
@@ -364,7 +377,11 @@ function isElementScrolledOutsideView(element, scrollContainers) {
  * @return {?} Whether the element is clipped
  */
 function isElementClippedByScrolling(element, scrollContainers) {
-    return scrollContainers.some(function (scrollContainerRect) {
+    return scrollContainers.some((/**
+     * @param {?} scrollContainerRect
+     * @return {?}
+     */
+    function (scrollContainerRect) {
         /** @type {?} */
         var clippedAbove = element.top < scrollContainerRect.top;
         /** @type {?} */
@@ -374,12 +391,12 @@ function isElementClippedByScrolling(element, scrollContainers) {
         /** @type {?} */
         var clippedRight = element.right > scrollContainerRect.right;
         return clippedAbove || clippedBelow || clippedLeft || clippedRight;
-    });
+    }));
 }
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Strategy that will update the element position as the user is scrolling.
@@ -426,7 +443,10 @@ RepositionScrollStrategy = /** @class */ (function () {
         if (!this._scrollSubscription) {
             /** @type {?} */
             var throttle = this._config ? this._config.scrollThrottle : 0;
-            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe(function () {
+            this._scrollSubscription = this._scrollDispatcher.scrolled(throttle).subscribe((/**
+             * @return {?}
+             */
+            function () {
                 _this._overlayRef.updatePosition();
                 // TODO(crisbeto): make `close` on by default once all components can handle it.
                 if (_this._config && _this._config.autoClose) {
@@ -439,10 +459,13 @@ RepositionScrollStrategy = /** @class */ (function () {
                     var parentRects = [{ width: width, height: height, bottom: height, right: width, top: 0, left: 0 }];
                     if (isElementScrolledOutsideView(overlayRect, parentRects)) {
                         _this.disable();
-                        _this._ngZone.run(function () { return _this._overlayRef.detach(); });
+                        _this._ngZone.run((/**
+                         * @return {?}
+                         */
+                        function () { return _this._overlayRef.detach(); }));
                     }
                 }
-            });
+            }));
         }
     };
     /** Disables repositioning of the attached overlay on scroll. */
@@ -475,7 +498,7 @@ RepositionScrollStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Options for how an overlay will handle scrolling.
@@ -492,22 +515,36 @@ var ScrollStrategyOptions = /** @class */ (function () {
         /**
          * Do nothing on scroll.
          */
-        this.noop = function () { return new NoopScrollStrategy(); };
+        this.noop = (/**
+         * @return {?}
+         */
+        function () { return new NoopScrollStrategy(); });
         /**
          * Close the overlay as soon as the user scrolls.
          * @param config Configuration to be used inside the scroll strategy.
          */
-        this.close = function (config) { return new CloseScrollStrategy(_this._scrollDispatcher, _this._ngZone, _this._viewportRuler, config); };
+        this.close = (/**
+         * @param {?=} config
+         * @return {?}
+         */
+        function (config) { return new CloseScrollStrategy(_this._scrollDispatcher, _this._ngZone, _this._viewportRuler, config); });
         /**
          * Block scrolling.
          */
-        this.block = function () { return new BlockScrollStrategy(_this._viewportRuler, _this._document); };
+        this.block = (/**
+         * @return {?}
+         */
+        function () { return new BlockScrollStrategy(_this._viewportRuler, _this._document); });
         /**
          * Update the overlay's position on scroll.
          * @param config Configuration to be used inside the scroll strategy.
          * Allows debouncing the reposition calls.
          */
-        this.reposition = function (config) { return new RepositionScrollStrategy(_this._scrollDispatcher, _this._viewportRuler, _this._ngZone, config); };
+        this.reposition = (/**
+         * @param {?=} config
+         * @return {?}
+         */
+        function (config) { return new RepositionScrollStrategy(_this._scrollDispatcher, _this._viewportRuler, _this._ngZone, config); });
         this._document = document;
     }
     ScrollStrategyOptions.decorators = [
@@ -520,18 +557,18 @@ var ScrollStrategyOptions = /** @class */ (function () {
         { type: core.NgZone },
         { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ ScrollStrategyOptions.ngInjectableDef = core.defineInjectable({ factory: function ScrollStrategyOptions_Factory() { return new ScrollStrategyOptions(core.inject(scrolling.ScrollDispatcher), core.inject(scrolling.ViewportRuler), core.inject(core.NgZone), core.inject(common.DOCUMENT)); }, token: ScrollStrategyOptions, providedIn: "root" });
+    /** @nocollapse */ ScrollStrategyOptions.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function ScrollStrategyOptions_Factory() { return new ScrollStrategyOptions(core.ɵɵinject(scrolling.ScrollDispatcher), core.ɵɵinject(scrolling.ViewportRuler), core.ɵɵinject(core.NgZone), core.ɵɵinject(common.DOCUMENT)); }, token: ScrollStrategyOptions, providedIn: "root" });
     return ScrollStrategyOptions;
 }());
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Initial configuration used when creating an overlay.
@@ -565,13 +602,17 @@ OverlayConfig = /** @class */ (function () {
          */
         this.disposeOnNavigation = false;
         if (config) {
-            Object.keys(config).forEach(function (k) {
+            Object.keys(config).forEach((/**
+             * @param {?} k
+             * @return {?}
+             */
+            function (k) {
                 /** @type {?} */
                 var key = (/** @type {?} */ (k));
                 if (typeof config[key] !== 'undefined') {
                     _this[key] = config[key];
                 }
-            });
+            }));
         }
     }
     return OverlayConfig;
@@ -579,7 +620,7 @@ OverlayConfig = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * The points of the origin element and the overlay element to connect.
@@ -698,7 +739,7 @@ function validateHorizontalPosition(property, value) {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Service for dispatching keyboard events that land on the body to appropriate overlay ref,
@@ -715,7 +756,11 @@ var OverlayKeyboardDispatcher = /** @class */ (function () {
         /**
          * Keyboard event listener that will be attached to the body.
          */
-        this._keydownListener = function (event) {
+        this._keydownListener = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
             /** @type {?} */
             var overlays = _this._attachedOverlays;
             for (var i = overlays.length - 1; i > -1; i--) {
@@ -730,7 +775,7 @@ var OverlayKeyboardDispatcher = /** @class */ (function () {
                     break;
                 }
             }
-        };
+        });
         this._document = document;
     }
     /**
@@ -809,7 +854,7 @@ var OverlayKeyboardDispatcher = /** @class */ (function () {
     OverlayKeyboardDispatcher.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ OverlayKeyboardDispatcher.ngInjectableDef = core.defineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(core.inject(common.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
+    /** @nocollapse */ OverlayKeyboardDispatcher.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function OverlayKeyboardDispatcher_Factory() { return new OverlayKeyboardDispatcher(core.ɵɵinject(common.DOCUMENT)); }, token: OverlayKeyboardDispatcher, providedIn: "root" });
     return OverlayKeyboardDispatcher;
 }());
 /**
@@ -841,7 +886,7 @@ var OVERLAY_KEYBOARD_DISPATCHER_PROVIDER = {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Container inside which all overlays will render.
@@ -915,7 +960,7 @@ var OverlayContainer = /** @class */ (function () {
     OverlayContainer.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ OverlayContainer.ngInjectableDef = core.defineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(core.inject(common.DOCUMENT)); }, token: OverlayContainer, providedIn: "root" });
+    /** @nocollapse */ OverlayContainer.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function OverlayContainer_Factory() { return new OverlayContainer(core.ɵɵinject(common.DOCUMENT)); }, token: OverlayContainer, providedIn: "root" });
     return OverlayContainer;
 }());
 /**
@@ -943,7 +988,7 @@ var OVERLAY_CONTAINER_PROVIDER = {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Reference to an overlay that has been created with the Overlay service.
@@ -969,15 +1014,22 @@ OverlayRef = /** @class */ (function () {
         this._attachments = new rxjs.Subject();
         this._detachments = new rxjs.Subject();
         this._locationChanges = rxjs.Subscription.EMPTY;
-        this._keydownEventsObservable = new rxjs.Observable(function (observer) {
+        this._keydownEventsObservable = new rxjs.Observable((/**
+         * @param {?} observer
+         * @return {?}
+         */
+        function (observer) {
             /** @type {?} */
             var subscription = _this._keydownEvents.subscribe(observer);
             _this._keydownEventSubscriptions++;
-            return function () {
+            return (/**
+             * @return {?}
+             */
+            function () {
                 subscription.unsubscribe();
                 _this._keydownEventSubscriptions--;
-            };
-        });
+            });
+        }));
         /**
          * Stream of keydown events dispatched to this overlay.
          */
@@ -1078,12 +1130,15 @@ OverlayRef = /** @class */ (function () {
         this._ngZone.onStable
             .asObservable()
             .pipe(operators.take(1))
-            .subscribe(function () {
+            .subscribe((/**
+         * @return {?}
+         */
+        function () {
             // The overlay could've been detached before the zone has stabilized.
             if (_this.hasAttached()) {
                 _this.updatePosition();
             }
-        });
+        }));
         // Enable pointer events for the overlay pane element.
         this._togglePointerEvents(true);
         if (this._config.hasBackdrop) {
@@ -1099,7 +1154,10 @@ OverlayRef = /** @class */ (function () {
         // @breaking-change 8.0.0 remove the null check for `_location`
         // once the constructor parameter is made required.
         if (this._config.disposeOnNavigation && this._location) {
-            this._locationChanges = this._location.subscribe(function () { return _this.dispose(); });
+            this._locationChanges = this._location.subscribe((/**
+             * @return {?}
+             */
+            function () { return _this.dispose(); }));
         }
         return attachResult;
     };
@@ -1465,16 +1523,26 @@ OverlayRef = /** @class */ (function () {
         (/** @type {?} */ (this._host.parentElement)).insertBefore(this._backdropElement, this._host);
         // Forward backdrop clicks such that the consumer of the overlay can perform whatever
         // action desired when such a click occurs (usually closing the overlay).
-        this._backdropElement.addEventListener('click', function (event) { return _this._backdropClick.next(event); });
+        this._backdropElement.addEventListener('click', (/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) { return _this._backdropClick.next(event); }));
         // Add class to fade-in the backdrop after one frame.
         if (typeof requestAnimationFrame !== 'undefined') {
-            this._ngZone.runOutsideAngular(function () {
-                requestAnimationFrame(function () {
+            this._ngZone.runOutsideAngular((/**
+             * @return {?}
+             */
+            function () {
+                requestAnimationFrame((/**
+                 * @return {?}
+                 */
+                function () {
                     if (_this._backdropElement) {
                         _this._backdropElement.classList.add(showingClass);
                     }
-                });
-            });
+                }));
+            }));
         }
         else {
             this._backdropElement.classList.add(showingClass);
@@ -1529,7 +1597,10 @@ OverlayRef = /** @class */ (function () {
         /** @type {?} */
         var timeoutId;
         /** @type {?} */
-        var finishDetach = function () {
+        var finishDetach = (/**
+         * @return {?}
+         */
+        function () {
             // It may not be attached to anything in certain cases (e.g. unit tests).
             if (backdropToDetach && backdropToDetach.parentNode) {
                 backdropToDetach.parentNode.removeChild(backdropToDetach);
@@ -1544,18 +1615,24 @@ OverlayRef = /** @class */ (function () {
                 _this._toggleClasses((/** @type {?} */ (backdropToDetach)), _this._config.backdropClass, false);
             }
             clearTimeout(timeoutId);
-        };
+        });
         backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
-        this._ngZone.runOutsideAngular(function () {
+        this._ngZone.runOutsideAngular((/**
+         * @return {?}
+         */
+        function () {
             (/** @type {?} */ (backdropToDetach)).addEventListener('transitionend', finishDetach);
-        });
+        }));
         // If the backdrop doesn't have a transition, the `transitionend` event won't fire.
         // In this case we make it unclickable and we try to remove it after a delay.
         backdropToDetach.style.pointerEvents = 'none';
         // Run this outside the Angular zone because there's nothing that Angular cares about.
         // If it were to run inside the Angular zone, every test that used Overlay would have to be
         // either async or fakeAsync.
-        timeoutId = this._ngZone.runOutsideAngular(function () { return setTimeout(finishDetach, 500); });
+        timeoutId = this._ngZone.runOutsideAngular((/**
+         * @return {?}
+         */
+        function () { return setTimeout(finishDetach, 500); }));
     };
     /** Toggles a single CSS class or an array of classes on an element. */
     /**
@@ -1577,10 +1654,14 @@ OverlayRef = /** @class */ (function () {
     function (element, cssClasses, isAdd) {
         /** @type {?} */
         var classList = element.classList;
-        coercion.coerceArray(cssClasses).forEach(function (cssClass) {
+        coercion.coerceArray(cssClasses).forEach((/**
+         * @param {?} cssClass
+         * @return {?}
+         */
+        function (cssClass) {
             // We can't do a spread here, because IE doesn't support setting multiple classes.
             isAdd ? classList.add(cssClass) : classList.remove(cssClass);
-        });
+        }));
     };
     /** Detaches the overlay content next time the zone stabilizes. */
     /**
@@ -1598,7 +1679,10 @@ OverlayRef = /** @class */ (function () {
         // Normally we wouldn't have to explicitly run this outside the `NgZone`, however
         // if the consumer is using `zone-patch-rxjs`, the `Subscription.unsubscribe` call will
         // be patched to run inside the zone, which will throw us into an infinite loop.
-        this._ngZone.runOutsideAngular(function () {
+        this._ngZone.runOutsideAngular((/**
+         * @return {?}
+         */
+        function () {
             // We can't remove the host here immediately, because the overlay pane's content
             // might still be animating. This stream helps us avoid interrupting the animation
             // by waiting for the pane to become empty.
@@ -1606,7 +1690,10 @@ OverlayRef = /** @class */ (function () {
             var subscription = _this._ngZone.onStable
                 .asObservable()
                 .pipe(operators.takeUntil(rxjs.merge(_this._attachments, _this._detachments)))
-                .subscribe(function () {
+                .subscribe((/**
+             * @return {?}
+             */
+            function () {
                 // Needs a couple of checks for the pane and host, because
                 // they may have been removed by the time the zone stabilizes.
                 if (!_this._pane || !_this._host || _this._pane.children.length === 0) {
@@ -1619,8 +1706,8 @@ OverlayRef = /** @class */ (function () {
                     }
                     subscription.unsubscribe();
                 }
-            });
-        });
+            }));
+        }));
     };
     /** Disposes of a scroll strategy. */
     /**
@@ -1648,7 +1735,7 @@ OverlayRef = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 // TODO: refactor clipping detection into a separate thing (part of scrolling module)
 // TODO: doesn't handle both flexible width and height when it has to scroll along both axis.
@@ -1673,7 +1760,6 @@ var   /**
  */
 FlexibleConnectedPositionStrategy = /** @class */ (function () {
     function FlexibleConnectedPositionStrategy(connectedTo, _viewportRuler, _document, _platform, _overlayContainer) {
-        var _this = this;
         this._viewportRuler = _viewportRuler;
         this._document = _document;
         this._platform = _platform;
@@ -1709,7 +1795,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         /**
          * The Scrollable containers used to check scrollable view properties on position change.
          */
-        this.scrollables = [];
+        this._scrollables = [];
         /**
          * Ordered list of preferred positions, from most to least desirable.
          */
@@ -1730,10 +1816,6 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
          * Default offset for the overlay along the y axis.
          */
         this._offsetY = 0;
-        /**
-         * Amount of subscribers to the `positionChanges` stream.
-         */
-        this._positionChangeSubscriptions = 0;
         /**
          * Keeps track of the CSS classes that the position strategy has applied on the overlay panel.
          */
@@ -1741,15 +1823,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         /**
          * Observable sequence of position changes.
          */
-        this.positionChanges = new rxjs.Observable(function (observer) {
-            /** @type {?} */
-            var subscription = _this._positionChanges.subscribe(observer);
-            _this._positionChangeSubscriptions++;
-            return function () {
-                subscription.unsubscribe();
-                _this._positionChangeSubscriptions--;
-            };
-        });
+        this.positionChanges = this._positionChanges.asObservable();
         this.setOrigin(connectedTo);
     }
     Object.defineProperty(FlexibleConnectedPositionStrategy.prototype, "positions", {
@@ -1789,13 +1863,16 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         this._isInitialRender = true;
         this._lastPosition = null;
         this._resizeSubscription.unsubscribe();
-        this._resizeSubscription = this._viewportRuler.change().subscribe(function () {
+        this._resizeSubscription = this._viewportRuler.change().subscribe((/**
+         * @return {?}
+         */
+        function () {
             // When the window is resized, we want to trigger the next reposition as if it
             // was an initial render, in order for the strategy to pick a new optimal position,
             // otherwise position locking will cause it to stay at the old one.
             _this._isInitialRender = true;
             _this.apply();
-        });
+        }));
     };
     /**
      * Updates the position of the overlay element, using whichever preferred position relative
@@ -2050,7 +2127,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
      * @return {THIS}
      */
     function (scrollables) {
-        (/** @type {?} */ (this)).scrollables = scrollables;
+        (/** @type {?} */ (this))._scrollables = scrollables;
         return (/** @type {?} */ (this));
     };
     /**
@@ -2603,7 +2680,7 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         // Notify that the position has been changed along with its change properties.
         // We only emit if we've got any subscriptions, because the scroll visibility
         // calculcations can be somewhat expensive.
-        if (this._positionChangeSubscriptions > 0) {
+        if (this._positionChanges.observers.length) {
             /** @type {?} */
             var scrollableViewProperties = this._getScrollVisibility();
             /** @type {?} */
@@ -3051,9 +3128,13 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         // every time, we should be able to use the scrollTop of the containers if the size of those
         // containers hasn't changed.
         /** @type {?} */
-        var scrollContainerBounds = this.scrollables.map(function (scrollable) {
+        var scrollContainerBounds = this._scrollables.map((/**
+         * @param {?} scrollable
+         * @return {?}
+         */
+        function (scrollable) {
             return scrollable.getElementRef().nativeElement.getBoundingClientRect();
-        });
+        }));
         return {
             isOriginClipped: isElementClippedByScrolling(originBounds, scrollContainerBounds),
             isOriginOutsideView: isElementScrolledOutsideView(originBounds, scrollContainerBounds),
@@ -3081,9 +3162,14 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         for (var _i = 1; _i < arguments.length; _i++) {
             overflows[_i - 1] = arguments[_i];
         }
-        return overflows.reduce(function (currentValue, currentOverflow) {
+        return overflows.reduce((/**
+         * @param {?} currentValue
+         * @param {?} currentOverflow
+         * @return {?}
+         */
+        function (currentValue, currentOverflow) {
             return currentValue - Math.max(currentOverflow, 0);
-        }, length);
+        }), length);
     };
     /** Narrows the given viewport rect by the current _viewportMargin. */
     /**
@@ -3185,12 +3271,16 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
         }
         // TODO(crisbeto): remove these once Angular's template type
         // checking is advanced enough to catch these cases.
-        this._preferredPositions.forEach(function (pair) {
+        this._preferredPositions.forEach((/**
+         * @param {?} pair
+         * @return {?}
+         */
+        function (pair) {
             validateHorizontalPosition('originX', pair.originX);
             validateVerticalPosition('originY', pair.originY);
             validateHorizontalPosition('overlayX', pair.overlayX);
             validateVerticalPosition('overlayY', pair.overlayY);
-        });
+        }));
     };
     /** Adds a single CSS class or an array of classes on the overlay panel. */
     /**
@@ -3208,12 +3298,16 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
     function (cssClasses) {
         var _this = this;
         if (this._pane) {
-            coercion.coerceArray(cssClasses).forEach(function (cssClass) {
+            coercion.coerceArray(cssClasses).forEach((/**
+             * @param {?} cssClass
+             * @return {?}
+             */
+            function (cssClass) {
                 if (cssClass !== '' && _this._appliedPanelClasses.indexOf(cssClass) === -1) {
                     _this._appliedPanelClasses.push(cssClass);
                     _this._pane.classList.add(cssClass);
                 }
-            });
+            }));
         }
     };
     /** Clears the classes that the position strategy has applied from the overlay panel. */
@@ -3230,9 +3324,13 @@ FlexibleConnectedPositionStrategy = /** @class */ (function () {
     function () {
         var _this = this;
         if (this._pane) {
-            this._appliedPanelClasses.forEach(function (cssClass) {
+            this._appliedPanelClasses.forEach((/**
+             * @param {?} cssClass
+             * @return {?}
+             */
+            function (cssClass) {
                 _this._pane.classList.remove(cssClass);
-            });
+            }));
             this._appliedPanelClasses = [];
         }
     };
@@ -3285,7 +3383,7 @@ function extendStyles(dest, source) {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * A strategy for positioning overlays. Using this strategy, an overlay is given an
@@ -3646,7 +3744,7 @@ ConnectedPositionStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
 /**
@@ -4017,7 +4115,7 @@ GlobalPositionStrategy = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Builder for overlay position strategy.
@@ -4099,13 +4197,13 @@ var OverlayPositionBuilder = /** @class */ (function () {
         { type: platform.Platform },
         { type: OverlayContainer }
     ]; };
-    /** @nocollapse */ OverlayPositionBuilder.ngInjectableDef = core.defineInjectable({ factory: function OverlayPositionBuilder_Factory() { return new OverlayPositionBuilder(core.inject(scrolling.ViewportRuler), core.inject(common.DOCUMENT), core.inject(platform.Platform), core.inject(OverlayContainer)); }, token: OverlayPositionBuilder, providedIn: "root" });
+    /** @nocollapse */ OverlayPositionBuilder.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function OverlayPositionBuilder_Factory() { return new OverlayPositionBuilder(core.ɵɵinject(scrolling.ViewportRuler), core.ɵɵinject(common.DOCUMENT), core.ɵɵinject(platform.Platform), core.ɵɵinject(OverlayContainer)); }, token: OverlayPositionBuilder, providedIn: "root" });
     return OverlayPositionBuilder;
 }());
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Next overlay unique ID.
@@ -4273,7 +4371,7 @@ var Overlay = /** @class */ (function () {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Default set of positions for the overlay. Follows the behavior of a dropdown.
@@ -4572,12 +4670,16 @@ var CdkConnectedOverlay = /** @class */ (function () {
             this.positions = defaultPositionList;
         }
         this._overlayRef = this._overlay.create(this._buildConfig());
-        this._overlayRef.keydownEvents().subscribe(function (event) {
+        this._overlayRef.keydownEvents().subscribe((/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
             _this.overlayKeydown.next(event);
             if (event.keyCode === keycodes.ESCAPE) {
                 _this._detachOverlay();
             }
-        });
+        }));
     };
     /** Builds the overlay config based on the directive's inputs */
     /**
@@ -4636,14 +4738,19 @@ var CdkConnectedOverlay = /** @class */ (function () {
     function (positionStrategy) {
         var _this = this;
         /** @type {?} */
-        var positions = this.positions.map(function (currentPosition) { return ({
+        var positions = this.positions.map((/**
+         * @param {?} currentPosition
+         * @return {?}
+         */
+        function (currentPosition) { return ({
             originX: currentPosition.originX,
             originY: currentPosition.originY,
             overlayX: currentPosition.overlayX,
             overlayY: currentPosition.overlayY,
             offsetX: currentPosition.offsetX || _this.offsetX,
-            offsetY: currentPosition.offsetY || _this.offsetY
-        }); });
+            offsetY: currentPosition.offsetY || _this.offsetY,
+            panelClass: currentPosition.panelClass || undefined,
+        }); }));
         return positionStrategy
             .setOrigin(this.origin.elementRef)
             .withPositions(positions)
@@ -4669,7 +4776,11 @@ var CdkConnectedOverlay = /** @class */ (function () {
         /** @type {?} */
         var strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);
         this._updatePositionStrategy(strategy);
-        strategy.positionChanges.subscribe(function (p) { return _this.positionChange.emit(p); });
+        strategy.positionChanges.subscribe((/**
+         * @param {?} p
+         * @return {?}
+         */
+        function (p) { return _this.positionChange.emit(p); }));
         return strategy;
     };
     /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */
@@ -4697,9 +4808,13 @@ var CdkConnectedOverlay = /** @class */ (function () {
             this.attach.emit();
         }
         if (this.hasBackdrop) {
-            this._backdropSubscription = this._overlayRef.backdropClick().subscribe(function (event) {
+            this._backdropSubscription = this._overlayRef.backdropClick().subscribe((/**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
                 _this.backdropClick.emit(event);
-            });
+            }));
         }
         else {
             this._backdropSubscription.unsubscribe();
@@ -4770,7 +4885,10 @@ var CdkConnectedOverlay = /** @class */ (function () {
  * @return {?}
  */
 function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
-    return function () { return overlay.scrollStrategies.reposition(); };
+    return (/**
+     * @return {?}
+     */
+    function () { return overlay.scrollStrategies.reposition(); });
 }
 /**
  * \@docs-private
@@ -4784,7 +4902,7 @@ var CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 var OverlayModule = /** @class */ (function () {
     function OverlayModule() {
@@ -4819,7 +4937,7 @@ var OVERLAY_PROVIDERS = [
 
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * Alternative to OverlayContainer that supports correct displaying of overlay elements in
@@ -4857,7 +4975,10 @@ var FullscreenOverlayContainer = /** @class */ (function (_super) {
         var _this = this;
         _super.prototype._createContainer.call(this);
         this._adjustParentForFullscreenChange();
-        this._addFullscreenChangeListener(function () { return _this._adjustParentForFullscreenChange(); });
+        this._addFullscreenChangeListener((/**
+         * @return {?}
+         */
+        function () { return _this._adjustParentForFullscreenChange(); }));
     };
     /**
      * @private
@@ -4951,7 +5072,7 @@ var FullscreenOverlayContainer = /** @class */ (function (_super) {
     FullscreenOverlayContainer.ctorParameters = function () { return [
         { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
     ]; };
-    /** @nocollapse */ FullscreenOverlayContainer.ngInjectableDef = core.defineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(core.inject(common.DOCUMENT)); }, token: FullscreenOverlayContainer, providedIn: "root" });
+    /** @nocollapse */ FullscreenOverlayContainer.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function FullscreenOverlayContainer_Factory() { return new FullscreenOverlayContainer(core.ɵɵinject(common.DOCUMENT)); }, token: FullscreenOverlayContainer, providedIn: "root" });
     return FullscreenOverlayContainer;
 }(OverlayContainer));