@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/overlay/overlay-directives.js

@@ -51,270 +51,272 @@ export function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_FACTORY(overlay) {
  * Directive applied to an element to make it usable as an origin for an Overlay using a
  * ConnectedPositionStrategy.
  */
-let CdkOverlayOrigin = /** @class */ (() => {
-    class CdkOverlayOrigin {
-        constructor(
-        /** Reference to the element on which the directive is applied. */
-        elementRef) {
-            this.elementRef = elementRef;
-        }
+export class CdkOverlayOrigin {
+    constructor(
+    /** Reference to the element on which the directive is applied. */
+    elementRef) {
+        this.elementRef = elementRef;
     }
-    CdkOverlayOrigin.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
-                    exportAs: 'cdkOverlayOrigin',
-                },] }
-    ];
-    CdkOverlayOrigin.ctorParameters = () => [
-        { type: ElementRef }
-    ];
-    return CdkOverlayOrigin;
-})();
-export { CdkOverlayOrigin };
+}
+CdkOverlayOrigin.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',
+                exportAs: 'cdkOverlayOrigin',
+            },] }
+];
+CdkOverlayOrigin.ctorParameters = () => [
+    { type: ElementRef }
+];
 /**
  * Directive to facilitate declarative creation of an
  * Overlay using a FlexibleConnectedPositionStrategy.
  */
-let CdkConnectedOverlay = /** @class */ (() => {
-    class CdkConnectedOverlay {
-        // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.
-        constructor(_overlay, templateRef, viewContainerRef, scrollStrategyFactory, _dir) {
-            this._overlay = _overlay;
-            this._dir = _dir;
-            this._hasBackdrop = false;
-            this._lockPosition = false;
-            this._growAfterOpen = false;
-            this._flexibleDimensions = false;
-            this._push = false;
-            this._backdropSubscription = Subscription.EMPTY;
-            /** Margin between the overlay and the viewport edges. */
-            this.viewportMargin = 0;
-            /** Whether the overlay is open. */
-            this.open = false;
-            /** Event emitted when the backdrop is clicked. */
-            this.backdropClick = new EventEmitter();
-            /** Event emitted when the position has changed. */
-            this.positionChange = new EventEmitter();
-            /** Event emitted when the overlay has been attached. */
-            this.attach = new EventEmitter();
-            /** Event emitted when the overlay has been detached. */
-            this.detach = new EventEmitter();
-            /** Emits when there are keyboard events that are targeted at the overlay. */
-            this.overlayKeydown = new EventEmitter();
-            this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);
-            this._scrollStrategyFactory = scrollStrategyFactory;
-            this.scrollStrategy = this._scrollStrategyFactory();
+export class CdkConnectedOverlay {
+    // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.
+    constructor(_overlay, templateRef, viewContainerRef, scrollStrategyFactory, _dir) {
+        this._overlay = _overlay;
+        this._dir = _dir;
+        this._hasBackdrop = false;
+        this._lockPosition = false;
+        this._growAfterOpen = false;
+        this._flexibleDimensions = false;
+        this._push = false;
+        this._backdropSubscription = Subscription.EMPTY;
+        this._attachSubscription = Subscription.EMPTY;
+        this._detachSubscription = Subscription.EMPTY;
+        /** Margin between the overlay and the viewport edges. */
+        this.viewportMargin = 0;
+        /** Whether the overlay is open. */
+        this.open = false;
+        /** Event emitted when the backdrop is clicked. */
+        this.backdropClick = new EventEmitter();
+        /** Event emitted when the position has changed. */
+        this.positionChange = new EventEmitter();
+        /** Event emitted when the overlay has been attached. */
+        this.attach = new EventEmitter();
+        /** Event emitted when the overlay has been detached. */
+        this.detach = new EventEmitter();
+        /** Emits when there are keyboard events that are targeted at the overlay. */
+        this.overlayKeydown = new EventEmitter();
+        /** Emits when there are mouse outside click events that are targeted at the overlay. */
+        this.overlayOutsideClick = new EventEmitter();
+        this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);
+        this._scrollStrategyFactory = scrollStrategyFactory;
+        this.scrollStrategy = this._scrollStrategyFactory();
+    }
+    /** The offset in pixels for the overlay connection point on the x-axis */
+    get offsetX() { return this._offsetX; }
+    set offsetX(offsetX) {
+        this._offsetX = offsetX;
+        if (this._position) {
+            this._updatePositionStrategy(this._position);
         }
-        /** The offset in pixels for the overlay connection point on the x-axis */
-        get offsetX() { return this._offsetX; }
-        set offsetX(offsetX) {
-            this._offsetX = offsetX;
-            if (this._position) {
-                this._updatePositionStrategy(this._position);
-            }
+    }
+    /** The offset in pixels for the overlay connection point on the y-axis */
+    get offsetY() { return this._offsetY; }
+    set offsetY(offsetY) {
+        this._offsetY = offsetY;
+        if (this._position) {
+            this._updatePositionStrategy(this._position);
         }
-        /** The offset in pixels for the overlay connection point on the y-axis */
-        get offsetY() { return this._offsetY; }
-        set offsetY(offsetY) {
-            this._offsetY = offsetY;
-            if (this._position) {
-                this._updatePositionStrategy(this._position);
-            }
+    }
+    /** Whether or not the overlay should attach a backdrop. */
+    get hasBackdrop() { return this._hasBackdrop; }
+    set hasBackdrop(value) { this._hasBackdrop = coerceBooleanProperty(value); }
+    /** Whether or not the overlay should be locked when scrolling. */
+    get lockPosition() { return this._lockPosition; }
+    set lockPosition(value) { this._lockPosition = coerceBooleanProperty(value); }
+    /** Whether the overlay's width and height can be constrained to fit within the viewport. */
+    get flexibleDimensions() { return this._flexibleDimensions; }
+    set flexibleDimensions(value) {
+        this._flexibleDimensions = coerceBooleanProperty(value);
+    }
+    /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */
+    get growAfterOpen() { return this._growAfterOpen; }
+    set growAfterOpen(value) { this._growAfterOpen = coerceBooleanProperty(value); }
+    /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */
+    get push() { return this._push; }
+    set push(value) { this._push = coerceBooleanProperty(value); }
+    /** The associated overlay reference. */
+    get overlayRef() {
+        return this._overlayRef;
+    }
+    /** The element's layout direction. */
+    get dir() {
+        return this._dir ? this._dir.value : 'ltr';
+    }
+    ngOnDestroy() {
+        this._attachSubscription.unsubscribe();
+        this._detachSubscription.unsubscribe();
+        this._backdropSubscription.unsubscribe();
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
         }
-        /** Whether or not the overlay should attach a backdrop. */
-        get hasBackdrop() { return this._hasBackdrop; }
-        set hasBackdrop(value) { this._hasBackdrop = coerceBooleanProperty(value); }
-        /** Whether or not the overlay should be locked when scrolling. */
-        get lockPosition() { return this._lockPosition; }
-        set lockPosition(value) { this._lockPosition = coerceBooleanProperty(value); }
-        /** Whether the overlay's width and height can be constrained to fit within the viewport. */
-        get flexibleDimensions() { return this._flexibleDimensions; }
-        set flexibleDimensions(value) {
-            this._flexibleDimensions = coerceBooleanProperty(value);
+    }
+    ngOnChanges(changes) {
+        if (this._position) {
+            this._updatePositionStrategy(this._position);
+            this._overlayRef.updateSize({
+                width: this.width,
+                minWidth: this.minWidth,
+                height: this.height,
+                minHeight: this.minHeight,
+            });
+            if (changes['origin'] && this.open) {
+                this._position.apply();
+            }
         }
-        /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */
-        get growAfterOpen() { return this._growAfterOpen; }
-        set growAfterOpen(value) { this._growAfterOpen = coerceBooleanProperty(value); }
-        /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */
-        get push() { return this._push; }
-        set push(value) { this._push = coerceBooleanProperty(value); }
-        /** The associated overlay reference. */
-        get overlayRef() {
-            return this._overlayRef;
+        if (changes['open']) {
+            this.open ? this._attachOverlay() : this._detachOverlay();
         }
-        /** The element's layout direction. */
-        get dir() {
-            return this._dir ? this._dir.value : 'ltr';
+    }
+    /** Creates an overlay */
+    _createOverlay() {
+        if (!this.positions || !this.positions.length) {
+            this.positions = defaultPositionList;
         }
-        ngOnDestroy() {
-            if (this._overlayRef) {
-                this._overlayRef.dispose();
+        const overlayRef = this._overlayRef = this._overlay.create(this._buildConfig());
+        this._attachSubscription = overlayRef.attachments().subscribe(() => this.attach.emit());
+        this._detachSubscription = overlayRef.detachments().subscribe(() => this.detach.emit());
+        overlayRef.keydownEvents().subscribe((event) => {
+            this.overlayKeydown.next(event);
+            if (event.keyCode === ESCAPE && !hasModifierKey(event)) {
+                event.preventDefault();
+                this._detachOverlay();
             }
-            this._backdropSubscription.unsubscribe();
+        });
+        this._overlayRef.outsidePointerEvents().subscribe((event) => {
+            this.overlayOutsideClick.next(event);
+        });
+    }
+    /** Builds the overlay config based on the directive's inputs */
+    _buildConfig() {
+        const positionStrategy = this._position =
+            this.positionStrategy || this._createPositionStrategy();
+        const overlayConfig = new OverlayConfig({
+            direction: this._dir,
+            positionStrategy,
+            scrollStrategy: this.scrollStrategy,
+            hasBackdrop: this.hasBackdrop
+        });
+        if (this.width || this.width === 0) {
+            overlayConfig.width = this.width;
         }
-        ngOnChanges(changes) {
-            if (this._position) {
-                this._updatePositionStrategy(this._position);
-                this._overlayRef.updateSize({
-                    width: this.width,
-                    minWidth: this.minWidth,
-                    height: this.height,
-                    minHeight: this.minHeight,
-                });
-                if (changes['origin'] && this.open) {
-                    this._position.apply();
-                }
-            }
-            if (changes['open']) {
-                this.open ? this._attachOverlay() : this._detachOverlay();
-            }
+        if (this.height || this.height === 0) {
+            overlayConfig.height = this.height;
         }
-        /** Creates an overlay */
-        _createOverlay() {
-            if (!this.positions || !this.positions.length) {
-                this.positions = defaultPositionList;
-            }
-            this._overlayRef = this._overlay.create(this._buildConfig());
-            this._overlayRef.keydownEvents().subscribe((event) => {
-                this.overlayKeydown.next(event);
-                if (event.keyCode === ESCAPE && !hasModifierKey(event)) {
-                    event.preventDefault();
-                    this._detachOverlay();
-                }
-            });
+        if (this.minWidth || this.minWidth === 0) {
+            overlayConfig.minWidth = this.minWidth;
         }
-        /** Builds the overlay config based on the directive's inputs */
-        _buildConfig() {
-            const positionStrategy = this._position =
-                this.positionStrategy || this._createPositionStrategy();
-            const overlayConfig = new OverlayConfig({
-                direction: this._dir,
-                positionStrategy,
-                scrollStrategy: this.scrollStrategy,
-                hasBackdrop: this.hasBackdrop
-            });
-            if (this.width || this.width === 0) {
-                overlayConfig.width = this.width;
-            }
-            if (this.height || this.height === 0) {
-                overlayConfig.height = this.height;
-            }
-            if (this.minWidth || this.minWidth === 0) {
-                overlayConfig.minWidth = this.minWidth;
-            }
-            if (this.minHeight || this.minHeight === 0) {
-                overlayConfig.minHeight = this.minHeight;
-            }
-            if (this.backdropClass) {
-                overlayConfig.backdropClass = this.backdropClass;
-            }
-            if (this.panelClass) {
-                overlayConfig.panelClass = this.panelClass;
-            }
-            return overlayConfig;
+        if (this.minHeight || this.minHeight === 0) {
+            overlayConfig.minHeight = this.minHeight;
         }
-        /** Updates the state of a position strategy, based on the values of the directive inputs. */
-        _updatePositionStrategy(positionStrategy) {
-            const positions = this.positions.map(currentPosition => ({
-                originX: currentPosition.originX,
-                originY: currentPosition.originY,
-                overlayX: currentPosition.overlayX,
-                overlayY: currentPosition.overlayY,
-                offsetX: currentPosition.offsetX || this.offsetX,
-                offsetY: currentPosition.offsetY || this.offsetY,
-                panelClass: currentPosition.panelClass || undefined,
-            }));
-            return positionStrategy
-                .setOrigin(this.origin.elementRef)
-                .withPositions(positions)
-                .withFlexibleDimensions(this.flexibleDimensions)
-                .withPush(this.push)
-                .withGrowAfterOpen(this.growAfterOpen)
-                .withViewportMargin(this.viewportMargin)
-                .withLockedPosition(this.lockPosition)
-                .withTransformOriginOn(this.transformOriginSelector);
+        if (this.backdropClass) {
+            overlayConfig.backdropClass = this.backdropClass;
         }
-        /** Returns the position strategy of the overlay to be set on the overlay config */
-        _createPositionStrategy() {
-            const strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);
-            this._updatePositionStrategy(strategy);
-            strategy.positionChanges.subscribe(p => this.positionChange.emit(p));
-            return strategy;
+        if (this.panelClass) {
+            overlayConfig.panelClass = this.panelClass;
         }
-        /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */
-        _attachOverlay() {
-            if (!this._overlayRef) {
-                this._createOverlay();
-            }
-            else {
-                // Update the overlay size, in case the directive's inputs have changed
-                this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;
-            }
-            if (!this._overlayRef.hasAttached()) {
-                this._overlayRef.attach(this._templatePortal);
-                this.attach.emit();
-            }
-            if (this.hasBackdrop) {
-                this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {
-                    this.backdropClick.emit(event);
-                });
-            }
-            else {
-                this._backdropSubscription.unsubscribe();
-            }
+        return overlayConfig;
+    }
+    /** Updates the state of a position strategy, based on the values of the directive inputs. */
+    _updatePositionStrategy(positionStrategy) {
+        const positions = this.positions.map(currentPosition => ({
+            originX: currentPosition.originX,
+            originY: currentPosition.originY,
+            overlayX: currentPosition.overlayX,
+            overlayY: currentPosition.overlayY,
+            offsetX: currentPosition.offsetX || this.offsetX,
+            offsetY: currentPosition.offsetY || this.offsetY,
+            panelClass: currentPosition.panelClass || undefined,
+        }));
+        return positionStrategy
+            .setOrigin(this.origin.elementRef)
+            .withPositions(positions)
+            .withFlexibleDimensions(this.flexibleDimensions)
+            .withPush(this.push)
+            .withGrowAfterOpen(this.growAfterOpen)
+            .withViewportMargin(this.viewportMargin)
+            .withLockedPosition(this.lockPosition)
+            .withTransformOriginOn(this.transformOriginSelector);
+    }
+    /** Returns the position strategy of the overlay to be set on the overlay config */
+    _createPositionStrategy() {
+        const strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);
+        this._updatePositionStrategy(strategy);
+        strategy.positionChanges.subscribe(p => this.positionChange.emit(p));
+        return strategy;
+    }
+    /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */
+    _attachOverlay() {
+        if (!this._overlayRef) {
+            this._createOverlay();
         }
-        /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */
-        _detachOverlay() {
-            if (this._overlayRef) {
-                this._overlayRef.detach();
-                this.detach.emit();
-            }
+        else {
+            // Update the overlay size, in case the directive's inputs have changed
+            this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;
+        }
+        if (!this._overlayRef.hasAttached()) {
+            this._overlayRef.attach(this._templatePortal);
+        }
+        if (this.hasBackdrop) {
+            this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {
+                this.backdropClick.emit(event);
+            });
+        }
+        else {
             this._backdropSubscription.unsubscribe();
         }
     }
-    CdkConnectedOverlay.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
-                    exportAs: 'cdkConnectedOverlay'
-                },] }
-    ];
-    CdkConnectedOverlay.ctorParameters = () => [
-        { type: Overlay },
-        { type: TemplateRef },
-        { type: ViewContainerRef },
-        { type: undefined, decorators: [{ type: Inject, args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,] }] },
-        { type: Directionality, decorators: [{ type: Optional }] }
-    ];
-    CdkConnectedOverlay.propDecorators = {
-        origin: [{ type: Input, args: ['cdkConnectedOverlayOrigin',] }],
-        positions: [{ type: Input, args: ['cdkConnectedOverlayPositions',] }],
-        positionStrategy: [{ type: Input, args: ['cdkConnectedOverlayPositionStrategy',] }],
-        offsetX: [{ type: Input, args: ['cdkConnectedOverlayOffsetX',] }],
-        offsetY: [{ type: Input, args: ['cdkConnectedOverlayOffsetY',] }],
-        width: [{ type: Input, args: ['cdkConnectedOverlayWidth',] }],
-        height: [{ type: Input, args: ['cdkConnectedOverlayHeight',] }],
-        minWidth: [{ type: Input, args: ['cdkConnectedOverlayMinWidth',] }],
-        minHeight: [{ type: Input, args: ['cdkConnectedOverlayMinHeight',] }],
-        backdropClass: [{ type: Input, args: ['cdkConnectedOverlayBackdropClass',] }],
-        panelClass: [{ type: Input, args: ['cdkConnectedOverlayPanelClass',] }],
-        viewportMargin: [{ type: Input, args: ['cdkConnectedOverlayViewportMargin',] }],
-        scrollStrategy: [{ type: Input, args: ['cdkConnectedOverlayScrollStrategy',] }],
-        open: [{ type: Input, args: ['cdkConnectedOverlayOpen',] }],
-        transformOriginSelector: [{ type: Input, args: ['cdkConnectedOverlayTransformOriginOn',] }],
-        hasBackdrop: [{ type: Input, args: ['cdkConnectedOverlayHasBackdrop',] }],
-        lockPosition: [{ type: Input, args: ['cdkConnectedOverlayLockPosition',] }],
-        flexibleDimensions: [{ type: Input, args: ['cdkConnectedOverlayFlexibleDimensions',] }],
-        growAfterOpen: [{ type: Input, args: ['cdkConnectedOverlayGrowAfterOpen',] }],
-        push: [{ type: Input, args: ['cdkConnectedOverlayPush',] }],
-        backdropClick: [{ type: Output }],
-        positionChange: [{ type: Output }],
-        attach: [{ type: Output }],
-        detach: [{ type: Output }],
-        overlayKeydown: [{ type: Output }]
-    };
-    return CdkConnectedOverlay;
-})();
-export { CdkConnectedOverlay };
+    /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */
+    _detachOverlay() {
+        if (this._overlayRef) {
+            this._overlayRef.detach();
+        }
+        this._backdropSubscription.unsubscribe();
+    }
+}
+CdkConnectedOverlay.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',
+                exportAs: 'cdkConnectedOverlay'
+            },] }
+];
+CdkConnectedOverlay.ctorParameters = () => [
+    { type: Overlay },
+    { type: TemplateRef },
+    { type: ViewContainerRef },
+    { type: undefined, decorators: [{ type: Inject, args: [CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,] }] },
+    { type: Directionality, decorators: [{ type: Optional }] }
+];
+CdkConnectedOverlay.propDecorators = {
+    origin: [{ type: Input, args: ['cdkConnectedOverlayOrigin',] }],
+    positions: [{ type: Input, args: ['cdkConnectedOverlayPositions',] }],
+    positionStrategy: [{ type: Input, args: ['cdkConnectedOverlayPositionStrategy',] }],
+    offsetX: [{ type: Input, args: ['cdkConnectedOverlayOffsetX',] }],
+    offsetY: [{ type: Input, args: ['cdkConnectedOverlayOffsetY',] }],
+    width: [{ type: Input, args: ['cdkConnectedOverlayWidth',] }],
+    height: [{ type: Input, args: ['cdkConnectedOverlayHeight',] }],
+    minWidth: [{ type: Input, args: ['cdkConnectedOverlayMinWidth',] }],
+    minHeight: [{ type: Input, args: ['cdkConnectedOverlayMinHeight',] }],
+    backdropClass: [{ type: Input, args: ['cdkConnectedOverlayBackdropClass',] }],
+    panelClass: [{ type: Input, args: ['cdkConnectedOverlayPanelClass',] }],
+    viewportMargin: [{ type: Input, args: ['cdkConnectedOverlayViewportMargin',] }],
+    scrollStrategy: [{ type: Input, args: ['cdkConnectedOverlayScrollStrategy',] }],
+    open: [{ type: Input, args: ['cdkConnectedOverlayOpen',] }],
+    transformOriginSelector: [{ type: Input, args: ['cdkConnectedOverlayTransformOriginOn',] }],
+    hasBackdrop: [{ type: Input, args: ['cdkConnectedOverlayHasBackdrop',] }],
+    lockPosition: [{ type: Input, args: ['cdkConnectedOverlayLockPosition',] }],
+    flexibleDimensions: [{ type: Input, args: ['cdkConnectedOverlayFlexibleDimensions',] }],
+    growAfterOpen: [{ type: Input, args: ['cdkConnectedOverlayGrowAfterOpen',] }],
+    push: [{ type: Input, args: ['cdkConnectedOverlayPush',] }],
+    backdropClick: [{ type: Output }],
+    positionChange: [{ type: Output }],
+    attach: [{ type: Output }],
+    detach: [{ type: Output }],
+    overlayKeydown: [{ type: Output }],
+    overlayOutsideClick: [{ type: Output }]
+};
 /** @docs-private */
 export function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
     return () => overlay.scrollStrategies.reposition();
@@ -325,4 +327,4 @@ export const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {
     deps: [Overlay],
     useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-directives.js","sourceRoot":"","sources":["../../../../../../src/cdk/overlay/overlay-directives.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {ESCAPE, hasModifierKey} from '@angular/cdk/keycodes';\nimport {TemplatePortal} from '@angular/cdk/portal';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {Subscription} from 'rxjs';\nimport {Overlay} from './overlay';\nimport {OverlayConfig} from './overlay-config';\nimport {OverlayRef} from './overlay-ref';\nimport {ConnectedOverlayPositionChange} from './position/connected-position';\nimport {\n  ConnectedPosition,\n  FlexibleConnectedPositionStrategy,\n} from './position/flexible-connected-position-strategy';\nimport {\n  RepositionScrollStrategy,\n  RepositionScrollStrategyConfig,\n  ScrollStrategy,\n} from './scroll/index';\n\n\n/** Default set of positions for the overlay. Follows the behavior of a dropdown. */\nconst defaultPositionList: ConnectedPosition[] = [\n  {\n    originX: 'start',\n    originY: 'bottom',\n    overlayX: 'start',\n    overlayY: 'top'\n  },\n  {\n    originX: 'start',\n    originY: 'top',\n    overlayX: 'start',\n    overlayY: 'bottom'\n  },\n  {\n    originX: 'end',\n    originY: 'top',\n    overlayX: 'end',\n    overlayY: 'bottom'\n  },\n  {\n    originX: 'end',\n    originY: 'bottom',\n    overlayX: 'end',\n    overlayY: 'top'\n  }\n];\n\n/** Injection token that determines the scroll handling while the connected overlay is open. */\nexport const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY =\n    new InjectionToken<() => ScrollStrategy>('cdk-connected-overlay-scroll-strategy');\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_FACTORY(overlay: Overlay):\n  () => ScrollStrategy {\n  return (config?: RepositionScrollStrategyConfig) => overlay.scrollStrategies.reposition(config);\n}\n\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\n@Directive({\n  selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',\n  exportAs: 'cdkOverlayOrigin',\n})\nexport class CdkOverlayOrigin {\n  constructor(\n      /** Reference to the element on which the directive is applied. */\n      public elementRef: ElementRef) { }\n}\n\n\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\n@Directive({\n  selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',\n  exportAs: 'cdkConnectedOverlay'\n})\nexport class CdkConnectedOverlay implements OnDestroy, OnChanges {\n  private _overlayRef: OverlayRef;\n  private _templatePortal: TemplatePortal;\n  private _hasBackdrop = false;\n  private _lockPosition = false;\n  private _growAfterOpen = false;\n  private _flexibleDimensions = false;\n  private _push = false;\n  private _backdropSubscription = Subscription.EMPTY;\n  private _offsetX: number;\n  private _offsetY: number;\n  private _position: FlexibleConnectedPositionStrategy;\n  private _scrollStrategyFactory: () => ScrollStrategy;\n\n  /** Origin for the connected overlay. */\n  @Input('cdkConnectedOverlayOrigin') origin: CdkOverlayOrigin;\n\n  /** Registered connected position pairs. */\n  @Input('cdkConnectedOverlayPositions') positions: ConnectedPosition[];\n\n  /**\n   * This input overrides the positions input if specified. It lets users pass\n   * in arbitrary positioning strategies.\n   */\n  @Input('cdkConnectedOverlayPositionStrategy') positionStrategy: FlexibleConnectedPositionStrategy;\n\n  /** The offset in pixels for the overlay connection point on the x-axis */\n  @Input('cdkConnectedOverlayOffsetX')\n  get offsetX(): number { return this._offsetX; }\n  set offsetX(offsetX: number) {\n    this._offsetX = offsetX;\n\n    if (this._position) {\n      this._updatePositionStrategy(this._position);\n    }\n  }\n\n  /** The offset in pixels for the overlay connection point on the y-axis */\n  @Input('cdkConnectedOverlayOffsetY')\n  get offsetY() { return this._offsetY; }\n  set offsetY(offsetY: number) {\n    this._offsetY = offsetY;\n\n    if (this._position) {\n      this._updatePositionStrategy(this._position);\n    }\n  }\n\n  /** The width of the overlay panel. */\n  @Input('cdkConnectedOverlayWidth') width: number | string;\n\n  /** The height of the overlay panel. */\n  @Input('cdkConnectedOverlayHeight') height: number | string;\n\n  /** The min width of the overlay panel. */\n  @Input('cdkConnectedOverlayMinWidth') minWidth: number | string;\n\n  /** The min height of the overlay panel. */\n  @Input('cdkConnectedOverlayMinHeight') minHeight: number | string;\n\n  /** The custom class to be set on the backdrop element. */\n  @Input('cdkConnectedOverlayBackdropClass') backdropClass: string;\n\n  /** The custom class to add to the overlay pane element. */\n  @Input('cdkConnectedOverlayPanelClass') panelClass: string | string[];\n\n  /** Margin between the overlay and the viewport edges. */\n  @Input('cdkConnectedOverlayViewportMargin') viewportMargin: number = 0;\n\n  /** Strategy to be used when handling scroll events while the overlay is open. */\n  @Input('cdkConnectedOverlayScrollStrategy') scrollStrategy: ScrollStrategy;\n\n  /** Whether the overlay is open. */\n  @Input('cdkConnectedOverlayOpen') open: boolean = false;\n\n  /** CSS selector which to set the transform origin. */\n  @Input('cdkConnectedOverlayTransformOriginOn') transformOriginSelector: string;\n\n  /** Whether or not the overlay should attach a backdrop. */\n  @Input('cdkConnectedOverlayHasBackdrop')\n  get hasBackdrop() { return this._hasBackdrop; }\n  set hasBackdrop(value: any) { this._hasBackdrop = coerceBooleanProperty(value); }\n\n  /** Whether or not the overlay should be locked when scrolling. */\n  @Input('cdkConnectedOverlayLockPosition')\n  get lockPosition() { return this._lockPosition; }\n  set lockPosition(value: any) { this._lockPosition = coerceBooleanProperty(value); }\n\n  /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n  @Input('cdkConnectedOverlayFlexibleDimensions')\n  get flexibleDimensions() { return this._flexibleDimensions; }\n  set flexibleDimensions(value: boolean) {\n    this._flexibleDimensions = coerceBooleanProperty(value);\n  }\n\n  /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n  @Input('cdkConnectedOverlayGrowAfterOpen')\n  get growAfterOpen() { return this._growAfterOpen; }\n  set growAfterOpen(value: boolean) { this._growAfterOpen = coerceBooleanProperty(value); }\n\n  /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n  @Input('cdkConnectedOverlayPush')\n  get push() { return this._push; }\n  set push(value: boolean) { this._push = coerceBooleanProperty(value); }\n\n  /** Event emitted when the backdrop is clicked. */\n  @Output() backdropClick = new EventEmitter<MouseEvent>();\n\n  /** Event emitted when the position has changed. */\n  @Output() positionChange = new EventEmitter<ConnectedOverlayPositionChange>();\n\n  /** Event emitted when the overlay has been attached. */\n  @Output() attach = new EventEmitter<void>();\n\n  /** Event emitted when the overlay has been detached. */\n  @Output() detach = new EventEmitter<void>();\n\n  /** Emits when there are keyboard events that are targeted at the overlay. */\n  @Output() overlayKeydown = new EventEmitter<KeyboardEvent>();\n\n  // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.\n\n  constructor(\n      private _overlay: Overlay,\n      templateRef: TemplateRef<any>,\n      viewContainerRef: ViewContainerRef,\n      @Inject(CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY) scrollStrategyFactory: any,\n      @Optional() private _dir: Directionality) {\n    this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\n    this._scrollStrategyFactory = scrollStrategyFactory;\n    this.scrollStrategy = this._scrollStrategyFactory();\n  }\n\n  /** The associated overlay reference. */\n  get overlayRef(): OverlayRef {\n    return this._overlayRef;\n  }\n\n  /** The element's layout direction. */\n  get dir(): Direction {\n    return this._dir ? this._dir.value : 'ltr';\n  }\n\n  ngOnDestroy() {\n    if (this._overlayRef) {\n      this._overlayRef.dispose();\n    }\n\n    this._backdropSubscription.unsubscribe();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (this._position) {\n      this._updatePositionStrategy(this._position);\n      this._overlayRef.updateSize({\n        width: this.width,\n        minWidth: this.minWidth,\n        height: this.height,\n        minHeight: this.minHeight,\n      });\n\n      if (changes['origin'] && this.open) {\n        this._position.apply();\n      }\n    }\n\n    if (changes['open']) {\n      this.open ? this._attachOverlay() : this._detachOverlay();\n    }\n  }\n\n  /** Creates an overlay */\n  private _createOverlay() {\n    if (!this.positions || !this.positions.length) {\n      this.positions = defaultPositionList;\n    }\n\n    this._overlayRef = this._overlay.create(this._buildConfig());\n\n    this._overlayRef.keydownEvents().subscribe((event: KeyboardEvent) => {\n      this.overlayKeydown.next(event);\n\n      if (event.keyCode === ESCAPE && !hasModifierKey(event)) {\n        event.preventDefault();\n        this._detachOverlay();\n      }\n    });\n  }\n\n  /** Builds the overlay config based on the directive's inputs */\n  private _buildConfig(): OverlayConfig {\n    const positionStrategy = this._position =\n      this.positionStrategy || this._createPositionStrategy();\n    const overlayConfig = new OverlayConfig({\n      direction: this._dir,\n      positionStrategy,\n      scrollStrategy: this.scrollStrategy,\n      hasBackdrop: this.hasBackdrop\n    });\n\n    if (this.width || this.width === 0) {\n      overlayConfig.width = this.width;\n    }\n\n    if (this.height || this.height === 0) {\n      overlayConfig.height = this.height;\n    }\n\n    if (this.minWidth || this.minWidth === 0) {\n      overlayConfig.minWidth = this.minWidth;\n    }\n\n    if (this.minHeight || this.minHeight === 0) {\n      overlayConfig.minHeight = this.minHeight;\n    }\n\n    if (this.backdropClass) {\n      overlayConfig.backdropClass = this.backdropClass;\n    }\n\n    if (this.panelClass) {\n      overlayConfig.panelClass = this.panelClass;\n    }\n\n    return overlayConfig;\n  }\n\n  /** Updates the state of a position strategy, based on the values of the directive inputs. */\n  private _updatePositionStrategy(positionStrategy: FlexibleConnectedPositionStrategy) {\n    const positions: ConnectedPosition[] = this.positions.map(currentPosition => ({\n      originX: currentPosition.originX,\n      originY: currentPosition.originY,\n      overlayX: currentPosition.overlayX,\n      overlayY: currentPosition.overlayY,\n      offsetX: currentPosition.offsetX || this.offsetX,\n      offsetY: currentPosition.offsetY || this.offsetY,\n      panelClass: currentPosition.panelClass || undefined,\n    }));\n\n    return positionStrategy\n      .setOrigin(this.origin.elementRef)\n      .withPositions(positions)\n      .withFlexibleDimensions(this.flexibleDimensions)\n      .withPush(this.push)\n      .withGrowAfterOpen(this.growAfterOpen)\n      .withViewportMargin(this.viewportMargin)\n      .withLockedPosition(this.lockPosition)\n      .withTransformOriginOn(this.transformOriginSelector);\n  }\n\n  /** Returns the position strategy of the overlay to be set on the overlay config */\n  private _createPositionStrategy(): FlexibleConnectedPositionStrategy {\n    const strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);\n\n    this._updatePositionStrategy(strategy);\n    strategy.positionChanges.subscribe(p => this.positionChange.emit(p));\n\n    return strategy;\n  }\n\n  /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */\n  private _attachOverlay() {\n    if (!this._overlayRef) {\n      this._createOverlay();\n    } else {\n      // Update the overlay size, in case the directive's inputs have changed\n      this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;\n    }\n\n    if (!this._overlayRef.hasAttached()) {\n      this._overlayRef.attach(this._templatePortal);\n      this.attach.emit();\n    }\n\n    if (this.hasBackdrop) {\n      this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {\n        this.backdropClick.emit(event);\n      });\n    } else {\n      this._backdropSubscription.unsubscribe();\n    }\n  }\n\n  /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */\n  private _detachOverlay() {\n    if (this._overlayRef) {\n      this._overlayRef.detach();\n      this.detach.emit();\n    }\n\n    this._backdropSubscription.unsubscribe();\n  }\n\n  static ngAcceptInputType_hasBackdrop: BooleanInput;\n  static ngAcceptInputType_lockPosition: BooleanInput;\n  static ngAcceptInputType_flexibleDimensions: BooleanInput;\n  static ngAcceptInputType_growAfterOpen: BooleanInput;\n  static ngAcceptInputType_push: BooleanInput;\n}\n\n\n/** @docs-private */\nexport function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay):\n    () => RepositionScrollStrategy {\n  return () => overlay.scrollStrategies.reposition();\n}\n\n/** @docs-private */\nexport const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {\n  provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-directives.js","sourceRoot":"","sources":["../../../../../../src/cdk/overlay/overlay-directives.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {ESCAPE, hasModifierKey} from '@angular/cdk/keycodes';\nimport {TemplatePortal} from '@angular/cdk/portal';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {Subscription} from 'rxjs';\nimport {Overlay} from './overlay';\nimport {OverlayConfig} from './overlay-config';\nimport {OverlayRef} from './overlay-ref';\nimport {ConnectedOverlayPositionChange} from './position/connected-position';\nimport {\n  ConnectedPosition,\n  FlexibleConnectedPositionStrategy,\n} from './position/flexible-connected-position-strategy';\nimport {\n  RepositionScrollStrategy,\n  RepositionScrollStrategyConfig,\n  ScrollStrategy,\n} from './scroll/index';\n\n\n/** Default set of positions for the overlay. Follows the behavior of a dropdown. */\nconst defaultPositionList: ConnectedPosition[] = [\n  {\n    originX: 'start',\n    originY: 'bottom',\n    overlayX: 'start',\n    overlayY: 'top'\n  },\n  {\n    originX: 'start',\n    originY: 'top',\n    overlayX: 'start',\n    overlayY: 'bottom'\n  },\n  {\n    originX: 'end',\n    originY: 'top',\n    overlayX: 'end',\n    overlayY: 'bottom'\n  },\n  {\n    originX: 'end',\n    originY: 'bottom',\n    overlayX: 'end',\n    overlayY: 'top'\n  }\n];\n\n/** Injection token that determines the scroll handling while the connected overlay is open. */\nexport const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY =\n    new InjectionToken<() => ScrollStrategy>('cdk-connected-overlay-scroll-strategy');\n\n/** @docs-private @deprecated @breaking-change 8.0.0 */\nexport function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_FACTORY(overlay: Overlay):\n  () => ScrollStrategy {\n  return (config?: RepositionScrollStrategyConfig) => overlay.scrollStrategies.reposition(config);\n}\n\n/**\n * Directive applied to an element to make it usable as an origin for an Overlay using a\n * ConnectedPositionStrategy.\n */\n@Directive({\n  selector: '[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]',\n  exportAs: 'cdkOverlayOrigin',\n})\nexport class CdkOverlayOrigin {\n  constructor(\n      /** Reference to the element on which the directive is applied. */\n      public elementRef: ElementRef) { }\n}\n\n\n/**\n * Directive to facilitate declarative creation of an\n * Overlay using a FlexibleConnectedPositionStrategy.\n */\n@Directive({\n  selector: '[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]',\n  exportAs: 'cdkConnectedOverlay'\n})\nexport class CdkConnectedOverlay implements OnDestroy, OnChanges {\n  private _overlayRef: OverlayRef;\n  private _templatePortal: TemplatePortal;\n  private _hasBackdrop = false;\n  private _lockPosition = false;\n  private _growAfterOpen = false;\n  private _flexibleDimensions = false;\n  private _push = false;\n  private _backdropSubscription = Subscription.EMPTY;\n  private _attachSubscription = Subscription.EMPTY;\n  private _detachSubscription = Subscription.EMPTY;\n  private _offsetX: number;\n  private _offsetY: number;\n  private _position: FlexibleConnectedPositionStrategy;\n  private _scrollStrategyFactory: () => ScrollStrategy;\n\n  /** Origin for the connected overlay. */\n  @Input('cdkConnectedOverlayOrigin') origin: CdkOverlayOrigin;\n\n  /** Registered connected position pairs. */\n  @Input('cdkConnectedOverlayPositions') positions: ConnectedPosition[];\n\n  /**\n   * This input overrides the positions input if specified. It lets users pass\n   * in arbitrary positioning strategies.\n   */\n  @Input('cdkConnectedOverlayPositionStrategy') positionStrategy: FlexibleConnectedPositionStrategy;\n\n  /** The offset in pixels for the overlay connection point on the x-axis */\n  @Input('cdkConnectedOverlayOffsetX')\n  get offsetX(): number { return this._offsetX; }\n  set offsetX(offsetX: number) {\n    this._offsetX = offsetX;\n\n    if (this._position) {\n      this._updatePositionStrategy(this._position);\n    }\n  }\n\n  /** The offset in pixels for the overlay connection point on the y-axis */\n  @Input('cdkConnectedOverlayOffsetY')\n  get offsetY() { return this._offsetY; }\n  set offsetY(offsetY: number) {\n    this._offsetY = offsetY;\n\n    if (this._position) {\n      this._updatePositionStrategy(this._position);\n    }\n  }\n\n  /** The width of the overlay panel. */\n  @Input('cdkConnectedOverlayWidth') width: number | string;\n\n  /** The height of the overlay panel. */\n  @Input('cdkConnectedOverlayHeight') height: number | string;\n\n  /** The min width of the overlay panel. */\n  @Input('cdkConnectedOverlayMinWidth') minWidth: number | string;\n\n  /** The min height of the overlay panel. */\n  @Input('cdkConnectedOverlayMinHeight') minHeight: number | string;\n\n  /** The custom class to be set on the backdrop element. */\n  @Input('cdkConnectedOverlayBackdropClass') backdropClass: string;\n\n  /** The custom class to add to the overlay pane element. */\n  @Input('cdkConnectedOverlayPanelClass') panelClass: string | string[];\n\n  /** Margin between the overlay and the viewport edges. */\n  @Input('cdkConnectedOverlayViewportMargin') viewportMargin: number = 0;\n\n  /** Strategy to be used when handling scroll events while the overlay is open. */\n  @Input('cdkConnectedOverlayScrollStrategy') scrollStrategy: ScrollStrategy;\n\n  /** Whether the overlay is open. */\n  @Input('cdkConnectedOverlayOpen') open: boolean = false;\n\n  /** CSS selector which to set the transform origin. */\n  @Input('cdkConnectedOverlayTransformOriginOn') transformOriginSelector: string;\n\n  /** Whether or not the overlay should attach a backdrop. */\n  @Input('cdkConnectedOverlayHasBackdrop')\n  get hasBackdrop() { return this._hasBackdrop; }\n  set hasBackdrop(value: any) { this._hasBackdrop = coerceBooleanProperty(value); }\n\n  /** Whether or not the overlay should be locked when scrolling. */\n  @Input('cdkConnectedOverlayLockPosition')\n  get lockPosition() { return this._lockPosition; }\n  set lockPosition(value: any) { this._lockPosition = coerceBooleanProperty(value); }\n\n  /** Whether the overlay's width and height can be constrained to fit within the viewport. */\n  @Input('cdkConnectedOverlayFlexibleDimensions')\n  get flexibleDimensions() { return this._flexibleDimensions; }\n  set flexibleDimensions(value: boolean) {\n    this._flexibleDimensions = coerceBooleanProperty(value);\n  }\n\n  /** Whether the overlay can grow after the initial open when flexible positioning is turned on. */\n  @Input('cdkConnectedOverlayGrowAfterOpen')\n  get growAfterOpen() { return this._growAfterOpen; }\n  set growAfterOpen(value: boolean) { this._growAfterOpen = coerceBooleanProperty(value); }\n\n  /** Whether the overlay can be pushed on-screen if none of the provided positions fit. */\n  @Input('cdkConnectedOverlayPush')\n  get push() { return this._push; }\n  set push(value: boolean) { this._push = coerceBooleanProperty(value); }\n\n  /** Event emitted when the backdrop is clicked. */\n  @Output() backdropClick = new EventEmitter<MouseEvent>();\n\n  /** Event emitted when the position has changed. */\n  @Output() positionChange = new EventEmitter<ConnectedOverlayPositionChange>();\n\n  /** Event emitted when the overlay has been attached. */\n  @Output() attach = new EventEmitter<void>();\n\n  /** Event emitted when the overlay has been detached. */\n  @Output() detach = new EventEmitter<void>();\n\n  /** Emits when there are keyboard events that are targeted at the overlay. */\n  @Output() overlayKeydown = new EventEmitter<KeyboardEvent>();\n\n  /** Emits when there are mouse outside click events that are targeted at the overlay. */\n  @Output() overlayOutsideClick = new EventEmitter<MouseEvent>();\n\n  // TODO(jelbourn): inputs for size, scroll behavior, animation, etc.\n\n  constructor(\n      private _overlay: Overlay,\n      templateRef: TemplateRef<any>,\n      viewContainerRef: ViewContainerRef,\n      @Inject(CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY) scrollStrategyFactory: any,\n      @Optional() private _dir: Directionality) {\n    this._templatePortal = new TemplatePortal(templateRef, viewContainerRef);\n    this._scrollStrategyFactory = scrollStrategyFactory;\n    this.scrollStrategy = this._scrollStrategyFactory();\n  }\n\n  /** The associated overlay reference. */\n  get overlayRef(): OverlayRef {\n    return this._overlayRef;\n  }\n\n  /** The element's layout direction. */\n  get dir(): Direction {\n    return this._dir ? this._dir.value : 'ltr';\n  }\n\n  ngOnDestroy() {\n    this._attachSubscription.unsubscribe();\n    this._detachSubscription.unsubscribe();\n    this._backdropSubscription.unsubscribe();\n\n    if (this._overlayRef) {\n      this._overlayRef.dispose();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (this._position) {\n      this._updatePositionStrategy(this._position);\n      this._overlayRef.updateSize({\n        width: this.width,\n        minWidth: this.minWidth,\n        height: this.height,\n        minHeight: this.minHeight,\n      });\n\n      if (changes['origin'] && this.open) {\n        this._position.apply();\n      }\n    }\n\n    if (changes['open']) {\n      this.open ? this._attachOverlay() : this._detachOverlay();\n    }\n  }\n\n  /** Creates an overlay */\n  private _createOverlay() {\n    if (!this.positions || !this.positions.length) {\n      this.positions = defaultPositionList;\n    }\n\n    const overlayRef = this._overlayRef = this._overlay.create(this._buildConfig());\n    this._attachSubscription = overlayRef.attachments().subscribe(() => this.attach.emit());\n    this._detachSubscription = overlayRef.detachments().subscribe(() => this.detach.emit());\n    overlayRef.keydownEvents().subscribe((event: KeyboardEvent) => {\n      this.overlayKeydown.next(event);\n\n      if (event.keyCode === ESCAPE && !hasModifierKey(event)) {\n        event.preventDefault();\n        this._detachOverlay();\n      }\n    });\n\n    this._overlayRef.outsidePointerEvents().subscribe((event: MouseEvent) => {\n      this.overlayOutsideClick.next(event);\n    });\n  }\n\n  /** Builds the overlay config based on the directive's inputs */\n  private _buildConfig(): OverlayConfig {\n    const positionStrategy = this._position =\n      this.positionStrategy || this._createPositionStrategy();\n    const overlayConfig = new OverlayConfig({\n      direction: this._dir,\n      positionStrategy,\n      scrollStrategy: this.scrollStrategy,\n      hasBackdrop: this.hasBackdrop\n    });\n\n    if (this.width || this.width === 0) {\n      overlayConfig.width = this.width;\n    }\n\n    if (this.height || this.height === 0) {\n      overlayConfig.height = this.height;\n    }\n\n    if (this.minWidth || this.minWidth === 0) {\n      overlayConfig.minWidth = this.minWidth;\n    }\n\n    if (this.minHeight || this.minHeight === 0) {\n      overlayConfig.minHeight = this.minHeight;\n    }\n\n    if (this.backdropClass) {\n      overlayConfig.backdropClass = this.backdropClass;\n    }\n\n    if (this.panelClass) {\n      overlayConfig.panelClass = this.panelClass;\n    }\n\n    return overlayConfig;\n  }\n\n  /** Updates the state of a position strategy, based on the values of the directive inputs. */\n  private _updatePositionStrategy(positionStrategy: FlexibleConnectedPositionStrategy) {\n    const positions: ConnectedPosition[] = this.positions.map(currentPosition => ({\n      originX: currentPosition.originX,\n      originY: currentPosition.originY,\n      overlayX: currentPosition.overlayX,\n      overlayY: currentPosition.overlayY,\n      offsetX: currentPosition.offsetX || this.offsetX,\n      offsetY: currentPosition.offsetY || this.offsetY,\n      panelClass: currentPosition.panelClass || undefined,\n    }));\n\n    return positionStrategy\n      .setOrigin(this.origin.elementRef)\n      .withPositions(positions)\n      .withFlexibleDimensions(this.flexibleDimensions)\n      .withPush(this.push)\n      .withGrowAfterOpen(this.growAfterOpen)\n      .withViewportMargin(this.viewportMargin)\n      .withLockedPosition(this.lockPosition)\n      .withTransformOriginOn(this.transformOriginSelector);\n  }\n\n  /** Returns the position strategy of the overlay to be set on the overlay config */\n  private _createPositionStrategy(): FlexibleConnectedPositionStrategy {\n    const strategy = this._overlay.position().flexibleConnectedTo(this.origin.elementRef);\n\n    this._updatePositionStrategy(strategy);\n    strategy.positionChanges.subscribe(p => this.positionChange.emit(p));\n\n    return strategy;\n  }\n\n  /** Attaches the overlay and subscribes to backdrop clicks if backdrop exists */\n  private _attachOverlay() {\n    if (!this._overlayRef) {\n      this._createOverlay();\n    } else {\n      // Update the overlay size, in case the directive's inputs have changed\n      this._overlayRef.getConfig().hasBackdrop = this.hasBackdrop;\n    }\n\n    if (!this._overlayRef.hasAttached()) {\n      this._overlayRef.attach(this._templatePortal);\n    }\n\n    if (this.hasBackdrop) {\n      this._backdropSubscription = this._overlayRef.backdropClick().subscribe(event => {\n        this.backdropClick.emit(event);\n      });\n    } else {\n      this._backdropSubscription.unsubscribe();\n    }\n  }\n\n  /** Detaches the overlay and unsubscribes to backdrop clicks if backdrop exists */\n  private _detachOverlay() {\n    if (this._overlayRef) {\n      this._overlayRef.detach();\n    }\n\n    this._backdropSubscription.unsubscribe();\n  }\n\n  static ngAcceptInputType_hasBackdrop: BooleanInput;\n  static ngAcceptInputType_lockPosition: BooleanInput;\n  static ngAcceptInputType_flexibleDimensions: BooleanInput;\n  static ngAcceptInputType_growAfterOpen: BooleanInput;\n  static ngAcceptInputType_push: BooleanInput;\n}\n\n\n/** @docs-private */\nexport function CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay):\n    () => RepositionScrollStrategy {\n  return () => overlay.scrollStrategies.reposition();\n}\n\n/** @docs-private */\nexport const CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER = {\n  provide: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: CDK_CONNECTED_OVERLAY_SCROLL_STRATEGY_PROVIDER_FACTORY,\n};\n"]}