@angular/cdk 2.0.0-beta.11 → 2.0.0-beta.12

package/esm2015/observers.js.map

@@ -1 +1 @@
-{"version":3,"file":"observers.js","sources":["../../../src/cdk/observers/index.ts","../../../src/cdk/observers/observe-content.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport {MdMutationObserverFactory,ObserveContent,ObserversModule} from './public_api';\n","/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n\nimport {\n  Directive,\n  ElementRef,\n  NgModule,\n  Output,\n  Input,\n  EventEmitter,\n  OnDestroy,\n  AfterContentInit,\n  Injectable,\n  NgZone,\n} from '@angular/core';\nimport {Subject} from 'rxjs/Subject';\nimport {RxChain, debounceTime} from '@angular/cdk/rxjs';\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * \\@docs-private\n */\nexport class MdMutationObserverFactory {\n/**\n * @param {?} callback\n * @return {?}\n */\ncreate(callback): MutationObserver | null {\n    return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Injectable },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction MdMutationObserverFactory_tsickle_Closure_declarations() {\n/** @type {?} */\nMdMutationObserverFactory.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nMdMutationObserverFactory.ctorParameters;\n}\n\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\nexport class ObserveContent implements AfterContentInit, OnDestroy {\nprivate _observer: MutationObserver | null;\n/**\n * Event emitted for each change in the element's content.\n */\nevent = new EventEmitter<MutationRecord[]>();\n/**\n * Used for debouncing the emitted values to the observeContent event.\n */\nprivate _debouncer = new Subject<MutationRecord[]>();\n/**\n * Debounce interval for emitting the changes.\n */\ndebounce: number;\n/**\n * @param {?} _mutationObserverFactory\n * @param {?} _elementRef\n * @param {?} _ngZone\n */\nconstructor(\nprivate _mutationObserverFactory: MdMutationObserverFactory,\nprivate _elementRef: ElementRef,\nprivate _ngZone: NgZone) { }\n/**\n * @return {?}\n */\nngAfterContentInit() {\n    if (this.debounce > 0) {\n      this._ngZone.runOutsideAngular(() => {\n        RxChain.from(this._debouncer)\n          .call(debounceTime, this.debounce)\n          .subscribe((mutations: MutationRecord[]) => this.event.emit(mutations));\n      });\n    } else {\n      this._debouncer.subscribe(mutations => this.event.emit(mutations));\n    }\n\n    this._observer = this._ngZone.runOutsideAngular(() => {\n      return this._mutationObserverFactory.create((mutations: MutationRecord[]) => {\n        this._debouncer.next(mutations);\n      });\n    });\n\n    if (this._observer) {\n      this._observer.observe(this._elementRef.nativeElement, {\n        characterData: true,\n        childList: true,\n        subtree: true\n      });\n    }\n  }\n/**\n * @return {?}\n */\nngOnDestroy() {\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n\n    this._debouncer.complete();\n  }\nstatic decorators: DecoratorInvocation[] = [\n{ type: Directive, args: [{\n  selector: '[cdkObserveContent]'\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n{type: MdMutationObserverFactory, },\n{type: ElementRef, },\n{type: NgZone, },\n];\nstatic propDecorators: {[key: string]: DecoratorInvocation[]} = {\n'event': [{ type: Output, args: ['cdkObserveContent', ] },],\n'debounce': [{ type: Input },],\n};\n}\n\nfunction ObserveContent_tsickle_Closure_declarations() {\n/** @type {?} */\nObserveContent.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nObserveContent.ctorParameters;\n/** @type {?} */\nObserveContent.propDecorators;\n/** @type {?} */\nObserveContent.prototype._observer;\n/**\n * Event emitted for each change in the element's content.\n * @type {?}\n */\nObserveContent.prototype.event;\n/**\n * Used for debouncing the emitted values to the observeContent event.\n * @type {?}\n */\nObserveContent.prototype._debouncer;\n/**\n * Debounce interval for emitting the changes.\n * @type {?}\n */\nObserveContent.prototype.debounce;\n/** @type {?} */\nObserveContent.prototype._mutationObserverFactory;\n/** @type {?} */\nObserveContent.prototype._elementRef;\n/** @type {?} */\nObserveContent.prototype._ngZone;\n}\n\nexport class ObserversModule {static decorators: DecoratorInvocation[] = [\n{ type: NgModule, args: [{\n  exports: [ObserveContent],\n  declarations: [ObserveContent],\n  providers: [MdMutationObserverFactory]\n}, ] },\n];\n/**\n * @nocollapse\n */\nstatic ctorParameters: () => ({type: any, decorators?: DecoratorInvocation[]}|null)[] = () => [\n];\n}\n\nfunction ObserversModule_tsickle_Closure_declarations() {\n/** @type {?} */\nObserversModule.decorators;\n/**\n * @nocollapse\n * @type {?}\n */\nObserversModule.ctorParameters;\n}\n\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"observers.js","sources":["../../packages/cdk/observers/observe-content.js","../../packages/cdk/observers/index.js"],"sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Directive, ElementRef, NgModule, Output, Input, EventEmitter, Injectable, NgZone, } from '@angular/core';\nimport { Subject } from 'rxjs/Subject';\nimport { RxChain, debounceTime } from '@angular/cdk/rxjs';\n/**\n * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.\n * \\@docs-private\n */\nexport class MatMutationObserverFactory {\n    /**\n     * @param {?} callback\n     * @return {?}\n     */\n    create(callback) {\n        return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback);\n    }\n}\nMatMutationObserverFactory.decorators = [\n    { type: Injectable },\n];\n/**\n * @nocollapse\n */\nMatMutationObserverFactory.ctorParameters = () => [];\nfunction MatMutationObserverFactory_tsickle_Closure_declarations() {\n    /** @type {?} */\n    MatMutationObserverFactory.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    MatMutationObserverFactory.ctorParameters;\n}\n/**\n * Directive that triggers a callback whenever the content of\n * its associated element has changed.\n */\nexport class ObserveContent {\n    /**\n     * @param {?} _mutationObserverFactory\n     * @param {?} _elementRef\n     * @param {?} _ngZone\n     */\n    constructor(_mutationObserverFactory, _elementRef, _ngZone) {\n        this._mutationObserverFactory = _mutationObserverFactory;\n        this._elementRef = _elementRef;\n        this._ngZone = _ngZone;\n        /**\n         * Event emitted for each change in the element's content.\n         */\n        this.event = new EventEmitter();\n        /**\n         * Used for debouncing the emitted values to the observeContent event.\n         */\n        this._debouncer = new Subject();\n    }\n    /**\n     * @return {?}\n     */\n    ngAfterContentInit() {\n        if (this.debounce > 0) {\n            this._ngZone.runOutsideAngular(() => {\n                RxChain.from(this._debouncer)\n                    .call(debounceTime, this.debounce)\n                    .subscribe((mutations) => this.event.emit(mutations));\n            });\n        }\n        else {\n            this._debouncer.subscribe(mutations => this.event.emit(mutations));\n        }\n        this._observer = this._ngZone.runOutsideAngular(() => {\n            return this._mutationObserverFactory.create((mutations) => {\n                this._debouncer.next(mutations);\n            });\n        });\n        if (this._observer) {\n            this._observer.observe(this._elementRef.nativeElement, {\n                characterData: true,\n                childList: true,\n                subtree: true\n            });\n        }\n    }\n    /**\n     * @return {?}\n     */\n    ngOnDestroy() {\n        if (this._observer) {\n            this._observer.disconnect();\n        }\n        this._debouncer.complete();\n    }\n}\nObserveContent.decorators = [\n    { type: Directive, args: [{\n                selector: '[cdkObserveContent]',\n                exportAs: 'cdkObserveContent',\n            },] },\n];\n/**\n * @nocollapse\n */\nObserveContent.ctorParameters = () => [\n    { type: MatMutationObserverFactory, },\n    { type: ElementRef, },\n    { type: NgZone, },\n];\nObserveContent.propDecorators = {\n    'event': [{ type: Output, args: ['cdkObserveContent',] },],\n    'debounce': [{ type: Input },],\n};\nfunction ObserveContent_tsickle_Closure_declarations() {\n    /** @type {?} */\n    ObserveContent.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    ObserveContent.ctorParameters;\n    /** @type {?} */\n    ObserveContent.propDecorators;\n    /** @type {?} */\n    ObserveContent.prototype._observer;\n    /**\n     * Event emitted for each change in the element's content.\n     * @type {?}\n     */\n    ObserveContent.prototype.event;\n    /**\n     * Used for debouncing the emitted values to the observeContent event.\n     * @type {?}\n     */\n    ObserveContent.prototype._debouncer;\n    /**\n     * Debounce interval for emitting the changes.\n     * @type {?}\n     */\n    ObserveContent.prototype.debounce;\n    /** @type {?} */\n    ObserveContent.prototype._mutationObserverFactory;\n    /** @type {?} */\n    ObserveContent.prototype._elementRef;\n    /** @type {?} */\n    ObserveContent.prototype._ngZone;\n}\nexport class ObserversModule {\n}\nObserversModule.decorators = [\n    { type: NgModule, args: [{\n                exports: [ObserveContent],\n                declarations: [ObserveContent],\n                providers: [MatMutationObserverFactory]\n            },] },\n];\n/**\n * @nocollapse\n */\nObserversModule.ctorParameters = () => [];\nfunction ObserversModule_tsickle_Closure_declarations() {\n    /** @type {?} */\n    ObserversModule.decorators;\n    /**\n     * @nocollapse\n     * @type {?}\n     */\n    ObserversModule.ctorParameters;\n}\n//# sourceMappingURL=observe-content.js.map","/**\n * Generated bundle index. Do not edit.\n */\nexport { MatMutationObserverFactory, ObserveContent, ObserversModule } from './public-api';\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":"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"}

package/esm2015/overlay.js

@@ -9,10 +9,10 @@ import { ApplicationRef, ComponentFactoryResolver, Directive, ElementRef, EventE
 import { DomPortalHost, PortalModule, TemplatePortal } from '@angular/cdk/portal';
 import { Subject } from 'rxjs/Subject';
 import { ScrollDispatchModule, ScrollDispatcher, Scrollable, VIEWPORT_RULER_PROVIDER, ViewportRuler } from '@angular/cdk/scrolling';
+import { Subscription } from 'rxjs/Subscription';
 import { Directionality } from '@angular/cdk/bidi';
 import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { ESCAPE } from '@angular/cdk/keycodes';
-import { Subscription } from 'rxjs/Subscription';
 
 /**
  * Scroll strategy that doesn't do anything.
@@ -37,9 +37,9 @@ class NoopScrollStrategy {
  */
 class OverlayConfig {
     /**
-     * @param {?=} state
+     * @param {?=} config
      */
-    constructor(state) {
+    constructor(config) {
         /**
          * Strategy to be used when handling scroll events while the overlay is open.
          */
@@ -60,8 +60,8 @@ class OverlayConfig {
          * The direction of the text in the overlay panel.
          */
         this.direction = 'ltr';
-        if (state) {
-            Object.keys(state).forEach(key => this[key] = state[key]);
+        if (config) {
+            Object.keys(config).forEach(key => this[key] = config[key]);
         }
     }
 }
@@ -74,20 +74,20 @@ class OverlayRef {
     /**
      * @param {?} _portalHost
      * @param {?} _pane
-     * @param {?} _state
+     * @param {?} _config
      * @param {?} _ngZone
      */
-    constructor(_portalHost, _pane, _state, _ngZone) {
+    constructor(_portalHost, _pane, _config, _ngZone) {
         this._portalHost = _portalHost;
         this._pane = _pane;
-        this._state = _state;
+        this._config = _config;
         this._ngZone = _ngZone;
         this._backdropElement = null;
         this._backdropClick = new Subject();
         this._attachments = new Subject();
         this._detachments = new Subject();
-        if (_state.scrollStrategy) {
-            _state.scrollStrategy.attach(this);
+        if (_config.scrollStrategy) {
+            _config.scrollStrategy.attach(this);
         }
     }
     /**
@@ -104,29 +104,29 @@ class OverlayRef {
      */
     attach(portal) {
         let /** @type {?} */ attachResult = this._portalHost.attach(portal);
-        if (this._state.positionStrategy) {
-            this._state.positionStrategy.attach(this);
+        if (this._config.positionStrategy) {
+            this._config.positionStrategy.attach(this);
         }
-        // Update the pane element with the given state configuration.
+        // Update the pane element with the given configuration.
         this._updateStackingOrder();
         this.updateSize();
         this.updateDirection();
         this.updatePosition();
-        if (this._state.scrollStrategy) {
-            this._state.scrollStrategy.enable();
+        if (this._config.scrollStrategy) {
+            this._config.scrollStrategy.enable();
         }
         // Enable pointer events for the overlay pane element.
         this._togglePointerEvents(true);
-        if (this._state.hasBackdrop) {
+        if (this._config.hasBackdrop) {
             this._attachBackdrop();
         }
-        if (this._state.panelClass) {
+        if (this._config.panelClass) {
             // We can't do a spread here, because IE doesn't support setting multiple classes.
-            if (Array.isArray(this._state.panelClass)) {
-                this._state.panelClass.forEach(cls => this._pane.classList.add(cls));
+            if (Array.isArray(this._config.panelClass)) {
+                this._config.panelClass.forEach(cls => this._pane.classList.add(cls));
             }
             else {
-                this._pane.classList.add(this._state.panelClass);
+                this._pane.classList.add(this._config.panelClass);
             }
         }
         // Only emit the `attachments` event once all other setup is done.
@@ -135,7 +135,7 @@ class OverlayRef {
     }
     /**
      * Detaches an overlay from a portal.
-     * @return {?} Resolves when the overlay has been detached.
+     * @return {?} The portal detachment result.
      */
     detach() {
         this.detachBackdrop();
@@ -143,10 +143,13 @@ class OverlayRef {
         // This is necessary because otherwise the pane element will cover the page and disable
         // pointer events therefore. Depends on the position strategy and the applied pane boundaries.
         this._togglePointerEvents(false);
-        if (this._state.scrollStrategy) {
-            this._state.scrollStrategy.disable();
+        if (this._config.positionStrategy && this._config.positionStrategy.detach) {
+            this._config.positionStrategy.detach();
         }
-        let /** @type {?} */ detachmentResult = this._portalHost.detach();
+        if (this._config.scrollStrategy) {
+            this._config.scrollStrategy.disable();
+        }
+        const /** @type {?} */ detachmentResult = this._portalHost.detach();
         // Only emit after everything is detached.
         this._detachments.next();
         return detachmentResult;
@@ -156,11 +159,11 @@ class OverlayRef {
      * @return {?}
      */
     dispose() {
-        if (this._state.positionStrategy) {
-            this._state.positionStrategy.dispose();
+        if (this._config.positionStrategy) {
+            this._config.positionStrategy.dispose();
         }
-        if (this._state.scrollStrategy) {
-            this._state.scrollStrategy.disable();
+        if (this._config.scrollStrategy) {
+            this._config.scrollStrategy.disable();
         }
         this.detachBackdrop();
         this._portalHost.dispose();
@@ -198,19 +201,19 @@ class OverlayRef {
         return this._detachments.asObservable();
     }
     /**
-     * Gets the current state config of the overlay.
+     * Gets the current config of the overlay.
      * @return {?}
      */
-    getState() {
-        return this._state;
+    getConfig() {
+        return this._config;
     }
     /**
      * Updates the position of the overlay based on the position strategy.
      * @return {?}
      */
     updatePosition() {
-        if (this._state.positionStrategy) {
-            this._state.positionStrategy.apply();
+        if (this._config.positionStrategy) {
+            this._config.positionStrategy.apply();
         }
     }
     /**
@@ -218,30 +221,30 @@ class OverlayRef {
      * @return {?}
      */
     updateDirection() {
-        this._pane.setAttribute('dir', /** @type {?} */ ((this._state.direction)));
+        this._pane.setAttribute('dir', /** @type {?} */ ((this._config.direction)));
     }
     /**
      * Updates the size of the overlay based on the overlay config.
      * @return {?}
      */
     updateSize() {
-        if (this._state.width || this._state.width === 0) {
-            this._pane.style.width = formatCssUnit(this._state.width);
+        if (this._config.width || this._config.width === 0) {
+            this._pane.style.width = formatCssUnit(this._config.width);
         }
-        if (this._state.height || this._state.height === 0) {
-            this._pane.style.height = formatCssUnit(this._state.height);
+        if (this._config.height || this._config.height === 0) {
+            this._pane.style.height = formatCssUnit(this._config.height);
         }
-        if (this._state.minWidth || this._state.minWidth === 0) {
-            this._pane.style.minWidth = formatCssUnit(this._state.minWidth);
+        if (this._config.minWidth || this._config.minWidth === 0) {
+            this._pane.style.minWidth = formatCssUnit(this._config.minWidth);
         }
-        if (this._state.minHeight || this._state.minHeight === 0) {
-            this._pane.style.minHeight = formatCssUnit(this._state.minHeight);
+        if (this._config.minHeight || this._config.minHeight === 0) {
+            this._pane.style.minHeight = formatCssUnit(this._config.minHeight);
         }
-        if (this._state.maxWidth || this._state.maxWidth === 0) {
-            this._pane.style.maxWidth = formatCssUnit(this._state.maxWidth);
+        if (this._config.maxWidth || this._config.maxWidth === 0) {
+            this._pane.style.maxWidth = formatCssUnit(this._config.maxWidth);
         }
-        if (this._state.maxHeight || this._state.maxHeight === 0) {
-            this._pane.style.maxHeight = formatCssUnit(this._state.maxHeight);
+        if (this._config.maxHeight || this._config.maxHeight === 0) {
+            this._pane.style.maxHeight = formatCssUnit(this._config.maxHeight);
         }
     }
     /**
@@ -259,8 +262,8 @@ class OverlayRef {
     _attachBackdrop() {
         this._backdropElement = document.createElement('div');
         this._backdropElement.classList.add('cdk-overlay-backdrop');
-        if (this._state.backdropClass) {
-            this._backdropElement.classList.add(this._state.backdropClass);
+        if (this._config.backdropClass) {
+            this._backdropElement.classList.add(this._config.backdropClass);
         } /** @type {?} */
         ((
         // Insert the backdrop before the pane in the DOM order,
@@ -309,8 +312,8 @@ class OverlayRef {
                 }
             };
             backdropToDetach.classList.remove('cdk-overlay-backdrop-showing');
-            if (this._state.backdropClass) {
-                backdropToDetach.classList.remove(this._state.backdropClass);
+            if (this._config.backdropClass) {
+                backdropToDetach.classList.remove(this._config.backdropClass);
             }
             backdropToDetach.addEventListener('transitionend', finishDetach);
             // If the backdrop doesn't have a transition, the `transitionend` event won't fire.
@@ -445,6 +448,9 @@ class ConnectedPositionStrategy {
     constructor(originPos, overlayPos, _connectedTo, _viewportRuler) {
         this._connectedTo = _connectedTo;
         this._viewportRuler = _viewportRuler;
+        /**
+         * Layout direction of the position strategy.
+         */
         this._dir = 'ltr';
         /**
          * The offset in pixels for the overlay connection point on the x-axis
@@ -458,6 +464,10 @@ class ConnectedPositionStrategy {
          * The Scrollable containers used to check scrollable view properties on position change.
          */
         this.scrollables = [];
+        /**
+         * Subscription to viewport resize events.
+         */
+        this._resizeSubscription = Subscription.EMPTY;
         /**
          * Ordered list of preferred positions, from most to least desirable.
          */
@@ -494,12 +504,23 @@ class ConnectedPositionStrategy {
     attach(overlayRef) {
         this._overlayRef = overlayRef;
         this._pane = overlayRef.overlayElement;
+        this._resizeSubscription.unsubscribe();
+        this._resizeSubscription = this._viewportRuler.change().subscribe(() => this.apply());
     }
     /**
      * Performs any cleanup after the element is destroyed.
      * @return {?}
      */
-    dispose() { }
+    dispose() {
+        this._resizeSubscription.unsubscribe();
+    }
+    /**
+     * \@docs-private
+     * @return {?}
+     */
+    detach() {
+        this._resizeSubscription.unsubscribe();
+    }
     /**
      * Updates the position of the overlay element, using whichever preferred position relative
      * to the origin fits on-screen.
@@ -1027,7 +1048,7 @@ const OVERLAY_CONTAINER_PROVIDER = {
  * Returns an error to be thrown when attempting to attach an already-attached scroll strategy.
  * @return {?}
  */
-function getMdScrollStrategyAlreadyAttachedError() {
+function getMatScrollStrategyAlreadyAttachedError() {
     return Error(`Scroll strategy has already been attached.`);
 }
 
@@ -1048,7 +1069,7 @@ class CloseScrollStrategy {
      */
     attach(overlayRef) {
         if (this._overlayRef) {
-            throw getMdScrollStrategyAlreadyAttachedError();
+            throw getMatScrollStrategyAlreadyAttachedError();
         }
         this._overlayRef = overlayRef;
     }
@@ -1157,7 +1178,7 @@ class RepositionScrollStrategy {
      */
     attach(overlayRef) {
         if (this._overlayRef) {
-            throw getMdScrollStrategyAlreadyAttachedError();
+            throw getMatScrollStrategyAlreadyAttachedError();
         }
         this._overlayRef = overlayRef;
     }
@@ -1233,9 +1254,9 @@ ScrollStrategyOptions.ctorParameters = () => [
  */
 let nextUniqueId = 0;
 /**
- * The default state for newly created overlays.
+ * The default config for newly created overlays.
  */
-let defaultState = new OverlayConfig();
+let defaultConfig = new OverlayConfig();
 /**
  * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
  * used as a low-level building building block for other components. Dialogs, tooltips, menus,
@@ -1265,13 +1286,13 @@ class Overlay {
     }
     /**
      * Creates an overlay.
-     * @param {?=} state State to apply to the overlay.
+     * @param {?=} config Config to apply to the overlay.
      * @return {?} Reference to the created overlay.
      */
-    create(state = defaultState) {
+    create(config = defaultConfig) {
         const /** @type {?} */ pane = this._createPaneElement();
         const /** @type {?} */ portalHost = this._createPortalHost(pane);
-        return new OverlayRef(portalHost, pane, state, this._ngZone);
+        return new OverlayRef(portalHost, pane, config, this._ngZone);
     }
     /**
      * Returns a position builder that can be used, via fluent API,
@@ -1317,6 +1338,74 @@ Overlay.ctorParameters = () => [
     { type: NgZone, },
 ];
 
+/**
+ * The FullscreenOverlayContainer is the alternative to OverlayContainer
+ * that supports correct displaying of overlay elements in Fullscreen mode
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen
+ * It should be provided in the root component that way:
+ * providers: [
+ *   {provide: OverlayContainer, useClass: FullscreenOverlayContainer}
+ * ],
+ */
+class FullscreenOverlayContainer extends OverlayContainer {
+    /**
+     * @return {?}
+     */
+    _createContainer() {
+        super._createContainer();
+        this._adjustParentForFullscreenChange();
+        this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());
+    }
+    /**
+     * @return {?}
+     */
+    _adjustParentForFullscreenChange() {
+        if (!this._containerElement) {
+            return;
+        }
+        let /** @type {?} */ fullscreenElement = this.getFullscreenElement();
+        let /** @type {?} */ parent = fullscreenElement || document.body;
+        parent.appendChild(this._containerElement);
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    _addFullscreenChangeListener(fn) {
+        if (document.fullscreenEnabled) {
+            document.addEventListener('fullscreenchange', fn);
+        }
+        else if (document.webkitFullscreenEnabled) {
+            document.addEventListener('webkitfullscreenchange', fn);
+        }
+        else if (((document)).mozFullScreenEnabled) {
+            document.addEventListener('mozfullscreenchange', fn);
+        }
+        else if (((document)).msFullscreenEnabled) {
+            document.addEventListener('MSFullscreenChange', fn);
+        }
+    }
+    /**
+     * When the page is put into fullscreen mode, a specific element is specified.
+     * Only that element and its children are visible when in fullscreen mode.
+     * @return {?}
+     */
+    getFullscreenElement() {
+        return document.fullscreenElement ||
+            document.webkitFullscreenElement ||
+            ((document)).mozFullScreenElement ||
+            ((document)).msFullscreenElement ||
+            null;
+    }
+}
+FullscreenOverlayContainer.decorators = [
+    { type: Injectable },
+];
+/**
+ * @nocollapse
+ */
+FullscreenOverlayContainer.ctorParameters = () => [];
+
 /**
  * Default set of positions for the overlay. Follows the behavior of a dropdown.
  */
@@ -1327,22 +1416,22 @@ const defaultPositionList = [
 /**
  * Injection token that determines the scroll handling while the connected overlay is open.
  */
-const MD_CONNECTED_OVERLAY_SCROLL_STRATEGY = new InjectionToken('md-connected-overlay-scroll-strategy');
+const MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY = new InjectionToken('mat-connected-overlay-scroll-strategy');
 /**
  * \@docs-private
  * @param {?} overlay
  * @return {?}
  */
-function MD_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+function MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
     return () => overlay.scrollStrategies.reposition();
 }
 /**
  * \@docs-private
  */
-const MD_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
-    provide: MD_CONNECTED_OVERLAY_SCROLL_STRATEGY,
+const MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
+    provide: MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY,
     deps: [Overlay],
-    useFactory: MD_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,
+    useFactory: MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,
 };
 /**
  * Directive applied to an element to make it usable as an origin for an Overlay using a
@@ -1681,7 +1770,7 @@ class ConnectedOverlayDirective {
             this._createOverlay();
         }
         this._position.withDirection(this.dir);
-        this._overlayRef.getState().direction = this.dir;
+        this._overlayRef.getConfig().direction = this.dir;
         this._initEscapeListener();
         if (!this._overlayRef.hasAttached()) {
             this._overlayRef.attach(this._templatePortal);
@@ -1743,7 +1832,7 @@ ConnectedOverlayDirective.ctorParameters = () => [
     { type: Renderer2, },
     { type: TemplateRef, },
     { type: ViewContainerRef, },
-    { type: undefined, decorators: [{ type: Inject, args: [MD_CONNECTED_OVERLAY_SCROLL_STRATEGY,] },] },
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY,] },] },
     { type: Directionality, decorators: [{ type: Optional },] },
 ];
 ConnectedOverlayDirective.propDecorators = {
@@ -1777,80 +1866,12 @@ ConnectedOverlayDirective.propDecorators = {
     'detach': [{ type: Output },],
 };
 
-/**
- * The FullscreenOverlayContainer is the alternative to OverlayContainer
- * that supports correct displaying of overlay elements in Fullscreen mode
- * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen
- * It should be provided in the root component that way:
- * providers: [
- *   {provide: OverlayContainer, useClass: FullscreenOverlayContainer}
- * ],
- */
-class FullscreenOverlayContainer extends OverlayContainer {
-    /**
-     * @return {?}
-     */
-    _createContainer() {
-        super._createContainer();
-        this._adjustParentForFullscreenChange();
-        this._addFullscreenChangeListener(() => this._adjustParentForFullscreenChange());
-    }
-    /**
-     * @return {?}
-     */
-    _adjustParentForFullscreenChange() {
-        if (!this._containerElement) {
-            return;
-        }
-        let /** @type {?} */ fullscreenElement = this.getFullscreenElement();
-        let /** @type {?} */ parent = fullscreenElement || document.body;
-        parent.appendChild(this._containerElement);
-    }
-    /**
-     * @param {?} fn
-     * @return {?}
-     */
-    _addFullscreenChangeListener(fn) {
-        if (document.fullscreenEnabled) {
-            document.addEventListener('fullscreenchange', fn);
-        }
-        else if (document.webkitFullscreenEnabled) {
-            document.addEventListener('webkitfullscreenchange', fn);
-        }
-        else if (((document)).mozFullScreenEnabled) {
-            document.addEventListener('mozfullscreenchange', fn);
-        }
-        else if (((document)).msFullscreenEnabled) {
-            document.addEventListener('MSFullscreenChange', fn);
-        }
-    }
-    /**
-     * When the page is put into fullscreen mode, a specific element is specified.
-     * Only that element and its children are visible when in fullscreen mode.
-     * @return {?}
-     */
-    getFullscreenElement() {
-        return document.fullscreenElement ||
-            document.webkitFullscreenElement ||
-            ((document)).mozFullScreenElement ||
-            ((document)).msFullscreenElement ||
-            null;
-    }
-}
-FullscreenOverlayContainer.decorators = [
-    { type: Injectable },
-];
-/**
- * @nocollapse
- */
-FullscreenOverlayContainer.ctorParameters = () => [];
-
 const OVERLAY_PROVIDERS = [
     Overlay,
     OverlayPositionBuilder,
     VIEWPORT_RULER_PROVIDER,
     OVERLAY_CONTAINER_PROVIDER,
-    MD_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,
+    MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER,
 ];
 class OverlayModule {
 }
@@ -1871,5 +1892,5 @@ OverlayModule.ctorParameters = () => [];
  * Generated bundle index. Do not edit.
  */
 
-export { OVERLAY_PROVIDERS, OverlayModule, Overlay, OverlayContainer, FullscreenOverlayContainer, OverlayRef, ConnectedOverlayDirective, OverlayOrigin, ViewportRuler, GlobalPositionStrategy, ConnectedPositionStrategy, VIEWPORT_RULER_PROVIDER, OverlayConfig, ConnectionPositionPair, ScrollingVisibility, ConnectedOverlayPositionChange, Scrollable, ScrollDispatcher, ScrollStrategyOptions, RepositionScrollStrategy, CloseScrollStrategy, NoopScrollStrategy, BlockScrollStrategy, OVERLAY_CONTAINER_PROVIDER as ɵb, OVERLAY_CONTAINER_PROVIDER_FACTORY as ɵa, MD_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵc, MD_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵe, MD_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵd, OverlayPositionBuilder as ɵf };
+export { Overlay, OverlayContainer, FullscreenOverlayContainer, OverlayRef, ConnectedOverlayDirective, OverlayOrigin, ViewportRuler, GlobalPositionStrategy, ConnectedPositionStrategy, VIEWPORT_RULER_PROVIDER, OverlayConfig, ConnectionPositionPair, ScrollingVisibility, ConnectedOverlayPositionChange, Scrollable, ScrollDispatcher, ScrollStrategyOptions, RepositionScrollStrategy, CloseScrollStrategy, NoopScrollStrategy, BlockScrollStrategy, OVERLAY_PROVIDERS, OverlayModule, OVERLAY_CONTAINER_PROVIDER as ɵb, OVERLAY_CONTAINER_PROVIDER_FACTORY as ɵa, MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY as ɵc, MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER as ɵe, MAT_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵd, OverlayPositionBuilder as ɵf };
 //# sourceMappingURL=overlay.js.map