@angular/cdk 10.0.0-rc.3 → 10.1.0

package/fesm2015/text-field.js

@@ -19,108 +19,102 @@ const listenerOptions = normalizePassiveListenerOptions({ passive: true });
  * Based on the following blog post:
  * https://medium.com/@brunn/detecting-autofilled-fields-in-javascript-aed598d25da7
  */
-let AutofillMonitor = /** @class */ (() => {
-    class AutofillMonitor {
-        constructor(_platform, _ngZone) {
-            this._platform = _platform;
-            this._ngZone = _ngZone;
-            this._monitoredElements = new Map();
+class AutofillMonitor {
+    constructor(_platform, _ngZone) {
+        this._platform = _platform;
+        this._ngZone = _ngZone;
+        this._monitoredElements = new Map();
+    }
+    monitor(elementOrRef) {
+        if (!this._platform.isBrowser) {
+            return EMPTY;
+        }
+        const element = coerceElement(elementOrRef);
+        const info = this._monitoredElements.get(element);
+        if (info) {
+            return info.subject.asObservable();
         }
-        monitor(elementOrRef) {
-            if (!this._platform.isBrowser) {
-                return EMPTY;
+        const result = new Subject();
+        const cssClass = 'cdk-text-field-autofilled';
+        const listener = ((event) => {
+            // Animation events fire on initial element render, we check for the presence of the autofill
+            // CSS class to make sure this is a real change in state, not just the initial render before
+            // we fire off events.
+            if (event.animationName === 'cdk-text-field-autofill-start' &&
+                !element.classList.contains(cssClass)) {
+                element.classList.add(cssClass);
+                this._ngZone.run(() => result.next({ target: event.target, isAutofilled: true }));
             }
-            const element = coerceElement(elementOrRef);
-            const info = this._monitoredElements.get(element);
-            if (info) {
-                return info.subject.asObservable();
+            else if (event.animationName === 'cdk-text-field-autofill-end' &&
+                element.classList.contains(cssClass)) {
+                element.classList.remove(cssClass);
+                this._ngZone.run(() => result.next({ target: event.target, isAutofilled: false }));
             }
-            const result = new Subject();
-            const cssClass = 'cdk-text-field-autofilled';
-            const listener = ((event) => {
-                // Animation events fire on initial element render, we check for the presence of the autofill
-                // CSS class to make sure this is a real change in state, not just the initial render before
-                // we fire off events.
-                if (event.animationName === 'cdk-text-field-autofill-start' &&
-                    !element.classList.contains(cssClass)) {
-                    element.classList.add(cssClass);
-                    this._ngZone.run(() => result.next({ target: event.target, isAutofilled: true }));
-                }
-                else if (event.animationName === 'cdk-text-field-autofill-end' &&
-                    element.classList.contains(cssClass)) {
-                    element.classList.remove(cssClass);
-                    this._ngZone.run(() => result.next({ target: event.target, isAutofilled: false }));
-                }
-            });
-            this._ngZone.runOutsideAngular(() => {
-                element.addEventListener('animationstart', listener, listenerOptions);
-                element.classList.add('cdk-text-field-autofill-monitored');
-            });
-            this._monitoredElements.set(element, {
-                subject: result,
-                unlisten: () => {
-                    element.removeEventListener('animationstart', listener, listenerOptions);
-                }
-            });
-            return result.asObservable();
-        }
-        stopMonitoring(elementOrRef) {
-            const element = coerceElement(elementOrRef);
-            const info = this._monitoredElements.get(element);
-            if (info) {
-                info.unlisten();
-                info.subject.complete();
-                element.classList.remove('cdk-text-field-autofill-monitored');
-                element.classList.remove('cdk-text-field-autofilled');
-                this._monitoredElements.delete(element);
+        });
+        this._ngZone.runOutsideAngular(() => {
+            element.addEventListener('animationstart', listener, listenerOptions);
+            element.classList.add('cdk-text-field-autofill-monitored');
+        });
+        this._monitoredElements.set(element, {
+            subject: result,
+            unlisten: () => {
+                element.removeEventListener('animationstart', listener, listenerOptions);
             }
+        });
+        return result.asObservable();
+    }
+    stopMonitoring(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        const info = this._monitoredElements.get(element);
+        if (info) {
+            info.unlisten();
+            info.subject.complete();
+            element.classList.remove('cdk-text-field-autofill-monitored');
+            element.classList.remove('cdk-text-field-autofilled');
+            this._monitoredElements.delete(element);
         }
-        ngOnDestroy() {
-            this._monitoredElements.forEach((_info, element) => this.stopMonitoring(element));
-        }
     }
-    AutofillMonitor.ɵprov = ɵɵdefineInjectable({ factory: function AutofillMonitor_Factory() { return new AutofillMonitor(ɵɵinject(Platform), ɵɵinject(NgZone)); }, token: AutofillMonitor, providedIn: "root" });
-    AutofillMonitor.decorators = [
-        { type: Injectable, args: [{ providedIn: 'root' },] }
-    ];
-    AutofillMonitor.ctorParameters = () => [
-        { type: Platform },
-        { type: NgZone }
-    ];
-    return AutofillMonitor;
-})();
+    ngOnDestroy() {
+        this._monitoredElements.forEach((_info, element) => this.stopMonitoring(element));
+    }
+}
+AutofillMonitor.ɵprov = ɵɵdefineInjectable({ factory: function AutofillMonitor_Factory() { return new AutofillMonitor(ɵɵinject(Platform), ɵɵinject(NgZone)); }, token: AutofillMonitor, providedIn: "root" });
+AutofillMonitor.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+AutofillMonitor.ctorParameters = () => [
+    { type: Platform },
+    { type: NgZone }
+];
 /** A directive that can be used to monitor the autofill state of an input. */
-let CdkAutofill = /** @class */ (() => {
-    class CdkAutofill {
-        constructor(_elementRef, _autofillMonitor) {
-            this._elementRef = _elementRef;
-            this._autofillMonitor = _autofillMonitor;
-            /** Emits when the autofill state of the element changes. */
-            this.cdkAutofill = new EventEmitter();
-        }
-        ngOnInit() {
-            this._autofillMonitor
-                .monitor(this._elementRef)
-                .subscribe(event => this.cdkAutofill.emit(event));
-        }
-        ngOnDestroy() {
-            this._autofillMonitor.stopMonitoring(this._elementRef);
-        }
+class CdkAutofill {
+    constructor(_elementRef, _autofillMonitor) {
+        this._elementRef = _elementRef;
+        this._autofillMonitor = _autofillMonitor;
+        /** Emits when the autofill state of the element changes. */
+        this.cdkAutofill = new EventEmitter();
+    }
+    ngOnInit() {
+        this._autofillMonitor
+            .monitor(this._elementRef)
+            .subscribe(event => this.cdkAutofill.emit(event));
+    }
+    ngOnDestroy() {
+        this._autofillMonitor.stopMonitoring(this._elementRef);
     }
-    CdkAutofill.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkAutofill]',
-                },] }
-    ];
-    CdkAutofill.ctorParameters = () => [
-        { type: ElementRef },
-        { type: AutofillMonitor }
-    ];
-    CdkAutofill.propDecorators = {
-        cdkAutofill: [{ type: Output }]
-    };
-    return CdkAutofill;
-})();
+}
+CdkAutofill.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkAutofill]',
+            },] }
+];
+CdkAutofill.ctorParameters = () => [
+    { type: ElementRef },
+    { type: AutofillMonitor }
+];
+CdkAutofill.propDecorators = {
+    cdkAutofill: [{ type: Output }]
+};
 
 /**
  * @license
@@ -130,244 +124,241 @@ let CdkAutofill = /** @class */ (() => {
  * found in the LICENSE file at https://angular.io/license
  */
 /** Directive to automatically resize a textarea to fit its content. */
-let CdkTextareaAutosize = /** @class */ (() => {
-    class CdkTextareaAutosize {
-        constructor(_elementRef, _platform, _ngZone, 
-        /** @breaking-change 11.0.0 make document required */
-        document) {
-            this._elementRef = _elementRef;
-            this._platform = _platform;
-            this._ngZone = _ngZone;
-            this._destroyed = new Subject();
-            this._enabled = true;
-            /**
-             * Value of minRows as of last resize. If the minRows has decreased, the
-             * height of the textarea needs to be recomputed to reflect the new minimum. The maxHeight
-             * does not have the same problem because it does not affect the textarea's scrollHeight.
-             */
-            this._previousMinRows = -1;
-            this._document = document;
-            this._textareaElement = this._elementRef.nativeElement;
-            this._measuringClass = _platform.FIREFOX ?
-                'cdk-textarea-autosize-measuring-firefox' :
-                'cdk-textarea-autosize-measuring';
-        }
-        /** Minimum amount of rows in the textarea. */
-        get minRows() { return this._minRows; }
-        set minRows(value) {
-            this._minRows = coerceNumberProperty(value);
-            this._setMinHeight();
-        }
-        /** Maximum amount of rows in the textarea. */
-        get maxRows() { return this._maxRows; }
-        set maxRows(value) {
-            this._maxRows = coerceNumberProperty(value);
-            this._setMaxHeight();
-        }
-        /** Whether autosizing is enabled or not */
-        get enabled() { return this._enabled; }
-        set enabled(value) {
-            value = coerceBooleanProperty(value);
-            // Only act if the actual value changed. This specifically helps to not run
-            // resizeToFitContent too early (i.e. before ngAfterViewInit)
-            if (this._enabled !== value) {
-                (this._enabled = value) ? this.resizeToFitContent(true) : this.reset();
-            }
-        }
-        /** Sets the minimum height of the textarea as determined by minRows. */
-        _setMinHeight() {
-            const minHeight = this.minRows && this._cachedLineHeight ?
-                `${this.minRows * this._cachedLineHeight}px` : null;
-            if (minHeight) {
-                this._textareaElement.style.minHeight = minHeight;
-            }
-        }
-        /** Sets the maximum height of the textarea as determined by maxRows. */
-        _setMaxHeight() {
-            const maxHeight = this.maxRows && this._cachedLineHeight ?
-                `${this.maxRows * this._cachedLineHeight}px` : null;
-            if (maxHeight) {
-                this._textareaElement.style.maxHeight = maxHeight;
-            }
-        }
-        ngAfterViewInit() {
-            if (this._platform.isBrowser) {
-                // Remember the height which we started with in case autosizing is disabled
-                this._initialHeight = this._textareaElement.style.height;
-                this.resizeToFitContent();
-                this._ngZone.runOutsideAngular(() => {
-                    const window = this._getWindow();
-                    fromEvent(window, 'resize')
-                        .pipe(auditTime(16), takeUntil(this._destroyed))
-                        .subscribe(() => this.resizeToFitContent(true));
-                });
-            }
-        }
-        ngOnDestroy() {
-            this._destroyed.next();
-            this._destroyed.complete();
-        }
+class CdkTextareaAutosize {
+    constructor(_elementRef, _platform, _ngZone, 
+    /** @breaking-change 11.0.0 make document required */
+    document) {
+        this._elementRef = _elementRef;
+        this._platform = _platform;
+        this._ngZone = _ngZone;
+        this._destroyed = new Subject();
+        this._enabled = true;
         /**
-         * Cache the height of a single-row textarea if it has not already been cached.
-         *
-         * We need to know how large a single "row" of a textarea is in order to apply minRows and
-         * maxRows. For the initial version, we will assume that the height of a single line in the
-         * textarea does not ever change.
+         * Value of minRows as of last resize. If the minRows has decreased, the
+         * height of the textarea needs to be recomputed to reflect the new minimum. The maxHeight
+         * does not have the same problem because it does not affect the textarea's scrollHeight.
          */
-        _cacheTextareaLineHeight() {
-            if (this._cachedLineHeight) {
-                return;
-            }
-            // Use a clone element because we have to override some styles.
-            let textareaClone = this._textareaElement.cloneNode(false);
-            textareaClone.rows = 1;
-            // Use `position: absolute` so that this doesn't cause a browser layout and use
-            // `visibility: hidden` so that nothing is rendered. Clear any other styles that
-            // would affect the height.
-            textareaClone.style.position = 'absolute';
-            textareaClone.style.visibility = 'hidden';
-            textareaClone.style.border = 'none';
-            textareaClone.style.padding = '0';
-            textareaClone.style.height = '';
-            textareaClone.style.minHeight = '';
-            textareaClone.style.maxHeight = '';
-            // In Firefox it happens that textarea elements are always bigger than the specified amount
-            // of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.
-            // As a workaround that removes the extra space for the scrollbar, we can just set overflow
-            // to hidden. This ensures that there is no invalid calculation of the line height.
-            // See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654
-            textareaClone.style.overflow = 'hidden';
-            this._textareaElement.parentNode.appendChild(textareaClone);
-            this._cachedLineHeight = textareaClone.clientHeight;
-            this._textareaElement.parentNode.removeChild(textareaClone);
-            // Min and max heights have to be re-calculated if the cached line height changes
-            this._setMinHeight();
-            this._setMaxHeight();
+        this._previousMinRows = -1;
+        this._document = document;
+        this._textareaElement = this._elementRef.nativeElement;
+        this._measuringClass = _platform.FIREFOX ?
+            'cdk-textarea-autosize-measuring-firefox' :
+            'cdk-textarea-autosize-measuring';
+    }
+    /** Minimum amount of rows in the textarea. */
+    get minRows() { return this._minRows; }
+    set minRows(value) {
+        this._minRows = coerceNumberProperty(value);
+        this._setMinHeight();
+    }
+    /** Maximum amount of rows in the textarea. */
+    get maxRows() { return this._maxRows; }
+    set maxRows(value) {
+        this._maxRows = coerceNumberProperty(value);
+        this._setMaxHeight();
+    }
+    /** Whether autosizing is enabled or not */
+    get enabled() { return this._enabled; }
+    set enabled(value) {
+        value = coerceBooleanProperty(value);
+        // Only act if the actual value changed. This specifically helps to not run
+        // resizeToFitContent too early (i.e. before ngAfterViewInit)
+        if (this._enabled !== value) {
+            (this._enabled = value) ? this.resizeToFitContent(true) : this.reset();
         }
-        ngDoCheck() {
-            if (this._platform.isBrowser) {
-                this.resizeToFitContent();
-            }
+    }
+    /** Sets the minimum height of the textarea as determined by minRows. */
+    _setMinHeight() {
+        const minHeight = this.minRows && this._cachedLineHeight ?
+            `${this.minRows * this._cachedLineHeight}px` : null;
+        if (minHeight) {
+            this._textareaElement.style.minHeight = minHeight;
         }
-        /**
-         * Resize the textarea to fit its content.
-         * @param force Whether to force a height recalculation. By default the height will be
-         *    recalculated only if the value changed since the last call.
-         */
-        resizeToFitContent(force = false) {
-            // If autosizing is disabled, just skip everything else
-            if (!this._enabled) {
-                return;
-            }
-            this._cacheTextareaLineHeight();
-            // If we haven't determined the line-height yet, we know we're still hidden and there's no point
-            // in checking the height of the textarea.
-            if (!this._cachedLineHeight) {
-                return;
-            }
-            const textarea = this._elementRef.nativeElement;
-            const value = textarea.value;
-            // Only resize if the value or minRows have changed since these calculations can be expensive.
-            if (!force && this._minRows === this._previousMinRows && value === this._previousValue) {
-                return;
-            }
-            const placeholderText = textarea.placeholder;
-            // Reset the textarea height to auto in order to shrink back to its default size.
-            // Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.
-            // Long placeholders that are wider than the textarea width may lead to a bigger scrollHeight
-            // value. To ensure that the scrollHeight is not bigger than the content, the placeholders
-            // need to be removed temporarily.
-            textarea.classList.add(this._measuringClass);
-            textarea.placeholder = '';
-            // The measuring class includes a 2px padding to workaround an issue with Chrome,
-            // so we account for that extra space here by subtracting 4 (2px top + 2px bottom).
-            const height = textarea.scrollHeight - 4;
-            // Use the scrollHeight to know how large the textarea *would* be if fit its entire value.
-            textarea.style.height = `${height}px`;
-            textarea.classList.remove(this._measuringClass);
-            textarea.placeholder = placeholderText;
+    }
+    /** Sets the maximum height of the textarea as determined by maxRows. */
+    _setMaxHeight() {
+        const maxHeight = this.maxRows && this._cachedLineHeight ?
+            `${this.maxRows * this._cachedLineHeight}px` : null;
+        if (maxHeight) {
+            this._textareaElement.style.maxHeight = maxHeight;
+        }
+    }
+    ngAfterViewInit() {
+        if (this._platform.isBrowser) {
+            // Remember the height which we started with in case autosizing is disabled
+            this._initialHeight = this._textareaElement.style.height;
+            this.resizeToFitContent();
             this._ngZone.runOutsideAngular(() => {
-                if (typeof requestAnimationFrame !== 'undefined') {
-                    requestAnimationFrame(() => this._scrollToCaretPosition(textarea));
-                }
-                else {
-                    setTimeout(() => this._scrollToCaretPosition(textarea));
-                }
+                const window = this._getWindow();
+                fromEvent(window, 'resize')
+                    .pipe(auditTime(16), takeUntil(this._destroyed))
+                    .subscribe(() => this.resizeToFitContent(true));
             });
-            this._previousValue = value;
-            this._previousMinRows = this._minRows;
         }
-        /**
-         * Resets the textarea to its original size
-         */
-        reset() {
-            // Do not try to change the textarea, if the initialHeight has not been determined yet
-            // This might potentially remove styles when reset() is called before ngAfterViewInit
-            if (this._initialHeight !== undefined) {
-                this._textareaElement.style.height = this._initialHeight;
-            }
+    }
+    ngOnDestroy() {
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /**
+     * Cache the height of a single-row textarea if it has not already been cached.
+     *
+     * We need to know how large a single "row" of a textarea is in order to apply minRows and
+     * maxRows. For the initial version, we will assume that the height of a single line in the
+     * textarea does not ever change.
+     */
+    _cacheTextareaLineHeight() {
+        if (this._cachedLineHeight) {
+            return;
         }
-        // In Ivy the `host` metadata will be merged, whereas in ViewEngine it is overridden. In order
-        // to avoid double event listeners, we need to use `HostListener`. Once Ivy is the default, we
-        // can move this back into `host`.
-        // tslint:disable:no-host-decorator-in-concrete
-        _noopInputHandler() {
-            // no-op handler that ensures we're running change detection on input events.
+        // Use a clone element because we have to override some styles.
+        let textareaClone = this._textareaElement.cloneNode(false);
+        textareaClone.rows = 1;
+        // Use `position: absolute` so that this doesn't cause a browser layout and use
+        // `visibility: hidden` so that nothing is rendered. Clear any other styles that
+        // would affect the height.
+        textareaClone.style.position = 'absolute';
+        textareaClone.style.visibility = 'hidden';
+        textareaClone.style.border = 'none';
+        textareaClone.style.padding = '0';
+        textareaClone.style.height = '';
+        textareaClone.style.minHeight = '';
+        textareaClone.style.maxHeight = '';
+        // In Firefox it happens that textarea elements are always bigger than the specified amount
+        // of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.
+        // As a workaround that removes the extra space for the scrollbar, we can just set overflow
+        // to hidden. This ensures that there is no invalid calculation of the line height.
+        // See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654
+        textareaClone.style.overflow = 'hidden';
+        this._textareaElement.parentNode.appendChild(textareaClone);
+        this._cachedLineHeight = textareaClone.clientHeight;
+        this._textareaElement.parentNode.removeChild(textareaClone);
+        // Min and max heights have to be re-calculated if the cached line height changes
+        this._setMinHeight();
+        this._setMaxHeight();
+    }
+    ngDoCheck() {
+        if (this._platform.isBrowser) {
+            this.resizeToFitContent();
         }
-        /** Access injected document if available or fallback to global document reference */
-        _getDocument() {
-            return this._document || document;
+    }
+    /**
+     * Resize the textarea to fit its content.
+     * @param force Whether to force a height recalculation. By default the height will be
+     *    recalculated only if the value changed since the last call.
+     */
+    resizeToFitContent(force = false) {
+        // If autosizing is disabled, just skip everything else
+        if (!this._enabled) {
+            return;
         }
-        /** Use defaultView of injected document if available or fallback to global window reference */
-        _getWindow() {
-            const doc = this._getDocument();
-            return doc.defaultView || window;
+        this._cacheTextareaLineHeight();
+        // If we haven't determined the line-height yet, we know we're still hidden and there's no point
+        // in checking the height of the textarea.
+        if (!this._cachedLineHeight) {
+            return;
         }
-        /**
-         * Scrolls a textarea to the caret position. On Firefox resizing the textarea will
-         * prevent it from scrolling to the caret position. We need to re-set the selection
-         * in order for it to scroll to the proper position.
-         */
-        _scrollToCaretPosition(textarea) {
-            const { selectionStart, selectionEnd } = textarea;
-            const document = this._getDocument();
-            // IE will throw an "Unspecified error" if we try to set the selection range after the
-            // element has been removed from the DOM. Assert that the directive hasn't been destroyed
-            // between the time we requested the animation frame and when it was executed.
-            // Also note that we have to assert that the textarea is focused before we set the
-            // selection range. Setting the selection range on a non-focused textarea will cause
-            // it to receive focus on IE and Edge.
-            if (!this._destroyed.isStopped && document.activeElement === textarea) {
-                textarea.setSelectionRange(selectionStart, selectionEnd);
+        const textarea = this._elementRef.nativeElement;
+        const value = textarea.value;
+        // Only resize if the value or minRows have changed since these calculations can be expensive.
+        if (!force && this._minRows === this._previousMinRows && value === this._previousValue) {
+            return;
+        }
+        const placeholderText = textarea.placeholder;
+        // Reset the textarea height to auto in order to shrink back to its default size.
+        // Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.
+        // Long placeholders that are wider than the textarea width may lead to a bigger scrollHeight
+        // value. To ensure that the scrollHeight is not bigger than the content, the placeholders
+        // need to be removed temporarily.
+        textarea.classList.add(this._measuringClass);
+        textarea.placeholder = '';
+        // The measuring class includes a 2px padding to workaround an issue with Chrome,
+        // so we account for that extra space here by subtracting 4 (2px top + 2px bottom).
+        const height = textarea.scrollHeight - 4;
+        // Use the scrollHeight to know how large the textarea *would* be if fit its entire value.
+        textarea.style.height = `${height}px`;
+        textarea.classList.remove(this._measuringClass);
+        textarea.placeholder = placeholderText;
+        this._ngZone.runOutsideAngular(() => {
+            if (typeof requestAnimationFrame !== 'undefined') {
+                requestAnimationFrame(() => this._scrollToCaretPosition(textarea));
+            }
+            else {
+                setTimeout(() => this._scrollToCaretPosition(textarea));
             }
+        });
+        this._previousValue = value;
+        this._previousMinRows = this._minRows;
+    }
+    /**
+     * Resets the textarea to its original size
+     */
+    reset() {
+        // Do not try to change the textarea, if the initialHeight has not been determined yet
+        // This might potentially remove styles when reset() is called before ngAfterViewInit
+        if (this._initialHeight !== undefined) {
+            this._textareaElement.style.height = this._initialHeight;
         }
     }
-    CdkTextareaAutosize.decorators = [
-        { type: Directive, args: [{
-                    selector: 'textarea[cdkTextareaAutosize]',
-                    exportAs: 'cdkTextareaAutosize',
-                    host: {
-                        'class': 'cdk-textarea-autosize',
-                        // Textarea elements that have the directive applied should have a single row by default.
-                        // Browsers normally show two rows by default and therefore this limits the minRows binding.
-                        'rows': '1',
-                    },
-                },] }
-    ];
-    CdkTextareaAutosize.ctorParameters = () => [
-        { type: ElementRef },
-        { type: Platform },
-        { type: NgZone },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
-    ];
-    CdkTextareaAutosize.propDecorators = {
-        minRows: [{ type: Input, args: ['cdkAutosizeMinRows',] }],
-        maxRows: [{ type: Input, args: ['cdkAutosizeMaxRows',] }],
-        enabled: [{ type: Input, args: ['cdkTextareaAutosize',] }],
-        _noopInputHandler: [{ type: HostListener, args: ['input',] }]
-    };
-    return CdkTextareaAutosize;
-})();
+    // In Ivy the `host` metadata will be merged, whereas in ViewEngine it is overridden. In order
+    // to avoid double event listeners, we need to use `HostListener`. Once Ivy is the default, we
+    // can move this back into `host`.
+    // tslint:disable:no-host-decorator-in-concrete
+    _noopInputHandler() {
+        // no-op handler that ensures we're running change detection on input events.
+    }
+    /** Access injected document if available or fallback to global document reference */
+    _getDocument() {
+        return this._document || document;
+    }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        const doc = this._getDocument();
+        return doc.defaultView || window;
+    }
+    /**
+     * Scrolls a textarea to the caret position. On Firefox resizing the textarea will
+     * prevent it from scrolling to the caret position. We need to re-set the selection
+     * in order for it to scroll to the proper position.
+     */
+    _scrollToCaretPosition(textarea) {
+        const { selectionStart, selectionEnd } = textarea;
+        const document = this._getDocument();
+        // IE will throw an "Unspecified error" if we try to set the selection range after the
+        // element has been removed from the DOM. Assert that the directive hasn't been destroyed
+        // between the time we requested the animation frame and when it was executed.
+        // Also note that we have to assert that the textarea is focused before we set the
+        // selection range. Setting the selection range on a non-focused textarea will cause
+        // it to receive focus on IE and Edge.
+        if (!this._destroyed.isStopped && document.activeElement === textarea) {
+            textarea.setSelectionRange(selectionStart, selectionEnd);
+        }
+    }
+}
+CdkTextareaAutosize.decorators = [
+    { type: Directive, args: [{
+                selector: 'textarea[cdkTextareaAutosize]',
+                exportAs: 'cdkTextareaAutosize',
+                host: {
+                    'class': 'cdk-textarea-autosize',
+                    // Textarea elements that have the directive applied should have a single row by default.
+                    // Browsers normally show two rows by default and therefore this limits the minRows binding.
+                    'rows': '1',
+                },
+            },] }
+];
+CdkTextareaAutosize.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Platform },
+    { type: NgZone },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+];
+CdkTextareaAutosize.propDecorators = {
+    minRows: [{ type: Input, args: ['cdkAutosizeMinRows',] }],
+    maxRows: [{ type: Input, args: ['cdkAutosizeMaxRows',] }],
+    enabled: [{ type: Input, args: ['cdkTextareaAutosize',] }],
+    _noopInputHandler: [{ type: HostListener, args: ['input',] }]
+};
 
 /**
  * @license
@@ -376,18 +367,15 @@ let CdkTextareaAutosize = /** @class */ (() => {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-let TextFieldModule = /** @class */ (() => {
-    class TextFieldModule {
-    }
-    TextFieldModule.decorators = [
-        { type: NgModule, args: [{
-                    declarations: [CdkAutofill, CdkTextareaAutosize],
-                    imports: [PlatformModule],
-                    exports: [CdkAutofill, CdkTextareaAutosize],
-                },] }
-    ];
-    return TextFieldModule;
-})();
+class TextFieldModule {
+}
+TextFieldModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [CdkAutofill, CdkTextareaAutosize],
+                imports: [PlatformModule],
+                exports: [CdkAutofill, CdkTextareaAutosize],
+            },] }
+];
 
 /**
  * @license