@angular/cdk
Version:
Angular Material Component Development Kit
310 lines • 43.2 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { coerceBooleanProperty, coerceNumberProperty, } from '@angular/cdk/coercion';
import { Directive, ElementRef, Input, NgZone, Optional, Inject, } from '@angular/core';
import { Platform } from '@angular/cdk/platform';
import { auditTime, takeUntil } from 'rxjs/operators';
import { fromEvent, Subject } from 'rxjs';
import { DOCUMENT } from '@angular/common';
import * as i0 from "@angular/core";
import * as i1 from "@angular/cdk/platform";
/** Directive to automatically resize a textarea to fit its content. */
class CdkTextareaAutosize {
/** 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();
}
}
get placeholder() {
return this._textareaElement.placeholder;
}
set placeholder(value) {
this._cachedPlaceholderHeight = undefined;
if (value) {
this._textareaElement.setAttribute('placeholder', value);
}
else {
this._textareaElement.removeAttribute('placeholder');
}
this._cacheTextareaPlaceholderHeight();
}
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._isViewInited = false;
/** Handles `focus` and `blur` events. */
this._handleFocusEvent = (event) => {
this._hasFocus = event.type === 'focus';
};
this._document = document;
this._textareaElement = this._elementRef.nativeElement;
}
/** 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));
this._textareaElement.addEventListener('focus', this._handleFocusEvent);
this._textareaElement.addEventListener('blur', this._handleFocusEvent);
});
this._isViewInited = true;
this.resizeToFitContent(true);
}
}
ngOnDestroy() {
this._textareaElement.removeEventListener('focus', this._handleFocusEvent);
this._textareaElement.removeEventListener('blur', this._handleFocusEvent);
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;
}
// 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;
textareaClone.remove();
// Min and max heights have to be re-calculated if the cached line height changes
this._setMinHeight();
this._setMaxHeight();
}
_measureScrollHeight() {
const element = this._textareaElement;
const previousMargin = element.style.marginBottom || '';
const isFirefox = this._platform.FIREFOX;
const needsMarginFiller = isFirefox && this._hasFocus;
const measuringClass = isFirefox
? 'cdk-textarea-autosize-measuring-firefox'
: 'cdk-textarea-autosize-measuring';
// In some cases the page might move around while we're measuring the `textarea` on Firefox. We
// work around it by assigning a temporary margin with the same height as the `textarea` so that
// it occupies the same amount of space. See #23233.
if (needsMarginFiller) {
element.style.marginBottom = `${element.clientHeight}px`;
}
// 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.
element.classList.add(measuringClass);
// 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 scrollHeight = element.scrollHeight - 4;
element.classList.remove(measuringClass);
if (needsMarginFiller) {
element.style.marginBottom = previousMargin;
}
return scrollHeight;
}
_cacheTextareaPlaceholderHeight() {
if (!this._isViewInited || this._cachedPlaceholderHeight != undefined) {
return;
}
if (!this.placeholder) {
this._cachedPlaceholderHeight = 0;
return;
}
const value = this._textareaElement.value;
this._textareaElement.value = this._textareaElement.placeholder;
this._cachedPlaceholderHeight = this._measureScrollHeight();
this._textareaElement.value = value;
}
ngDoCheck() {
if (this._platform.isBrowser) {
this.resizeToFitContent();
}
}
/**
* 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();
this._cacheTextareaPlaceholderHeight();
// 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 scrollHeight = this._measureScrollHeight();
const height = Math.max(scrollHeight, this._cachedPlaceholderHeight || 0);
// Use the scrollHeight to know how large the textarea *would* be if fit its entire value.
textarea.style.height = `${height}px`;
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;
}
}
_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;
// 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 && this._hasFocus) {
textarea.setSelectionRange(selectionStart, selectionEnd);
}
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CdkTextareaAutosize, deps: [{ token: i0.ElementRef }, { token: i1.Platform }, { token: i0.NgZone }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: CdkTextareaAutosize, selector: "textarea[cdkTextareaAutosize]", inputs: { minRows: ["cdkAutosizeMinRows", "minRows"], maxRows: ["cdkAutosizeMaxRows", "maxRows"], enabled: ["cdkTextareaAutosize", "enabled"], placeholder: "placeholder" }, host: { attributes: { "rows": "1" }, listeners: { "input": "_noopInputHandler()" }, classAttribute: "cdk-textarea-autosize" }, exportAs: ["cdkTextareaAutosize"], ngImport: i0 }); }
}
export { CdkTextareaAutosize };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: 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',
'(input)': '_noopInputHandler()',
},
}]
}], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i0.NgZone }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [DOCUMENT]
}] }]; }, propDecorators: { minRows: [{
type: Input,
args: ['cdkAutosizeMinRows']
}], maxRows: [{
type: Input,
args: ['cdkAutosizeMaxRows']
}], enabled: [{
type: Input,
args: ['cdkTextareaAutosize']
}], placeholder: [{
type: Input
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autosize.js","sourceRoot":"","sources":["../../../../../../src/cdk/text-field/autosize.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 {\n  BooleanInput,\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  NumberInput,\n} from '@angular/cdk/coercion';\nimport {\n  Directive,\n  ElementRef,\n  Input,\n  AfterViewInit,\n  DoCheck,\n  OnDestroy,\n  NgZone,\n  Optional,\n  Inject,\n} from '@angular/core';\nimport {Platform} from '@angular/cdk/platform';\nimport {auditTime, takeUntil} from 'rxjs/operators';\nimport {fromEvent, Subject} from 'rxjs';\nimport {DOCUMENT} from '@angular/common';\n\n/** Directive to automatically resize a textarea to fit its content. */\n@Directive({\n  selector: 'textarea[cdkTextareaAutosize]',\n  exportAs: 'cdkTextareaAutosize',\n  host: {\n    'class': 'cdk-textarea-autosize',\n    // Textarea elements that have the directive applied should have a single row by default.\n    // Browsers normally show two rows by default and therefore this limits the minRows binding.\n    'rows': '1',\n    '(input)': '_noopInputHandler()',\n  },\n})\nexport class CdkTextareaAutosize implements AfterViewInit, DoCheck, OnDestroy {\n  /** Keep track of the previous textarea value to avoid resizing when the value hasn't changed. */\n  private _previousValue?: string;\n  private _initialHeight: string | undefined;\n  private readonly _destroyed = new Subject<void>();\n\n  private _minRows: number;\n  private _maxRows: number;\n  private _enabled: boolean = true;\n\n  /**\n   * Value of minRows as of last resize. If the minRows has decreased, the\n   * height of the textarea needs to be recomputed to reflect the new minimum. The maxHeight\n   * does not have the same problem because it does not affect the textarea's scrollHeight.\n   */\n  private _previousMinRows: number = -1;\n\n  private _textareaElement: HTMLTextAreaElement;\n\n  /** Minimum amount of rows in the textarea. */\n  @Input('cdkAutosizeMinRows')\n  get minRows(): number {\n    return this._minRows;\n  }\n  set minRows(value: NumberInput) {\n    this._minRows = coerceNumberProperty(value);\n    this._setMinHeight();\n  }\n\n  /** Maximum amount of rows in the textarea. */\n  @Input('cdkAutosizeMaxRows')\n  get maxRows(): number {\n    return this._maxRows;\n  }\n  set maxRows(value: NumberInput) {\n    this._maxRows = coerceNumberProperty(value);\n    this._setMaxHeight();\n  }\n\n  /** Whether autosizing is enabled or not */\n  @Input('cdkTextareaAutosize')\n  get enabled(): boolean {\n    return this._enabled;\n  }\n  set enabled(value: BooleanInput) {\n    value = coerceBooleanProperty(value);\n\n    // Only act if the actual value changed. This specifically helps to not run\n    // resizeToFitContent too early (i.e. before ngAfterViewInit)\n    if (this._enabled !== value) {\n      (this._enabled = value) ? this.resizeToFitContent(true) : this.reset();\n    }\n  }\n\n  @Input()\n  get placeholder(): string {\n    return this._textareaElement.placeholder;\n  }\n  set placeholder(value: string) {\n    this._cachedPlaceholderHeight = undefined;\n\n    if (value) {\n      this._textareaElement.setAttribute('placeholder', value);\n    } else {\n      this._textareaElement.removeAttribute('placeholder');\n    }\n\n    this._cacheTextareaPlaceholderHeight();\n  }\n\n  /** Cached height of a textarea with a single row. */\n  private _cachedLineHeight: number;\n  /** Cached height of a textarea with only the placeholder. */\n  private _cachedPlaceholderHeight?: number;\n\n  /** Used to reference correct document/window */\n  protected _document?: Document;\n\n  private _hasFocus: boolean;\n\n  private _isViewInited = false;\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _platform: Platform,\n    private _ngZone: NgZone,\n    /** @breaking-change 11.0.0 make document required */\n    @Optional() @Inject(DOCUMENT) document?: any,\n  ) {\n    this._document = document;\n\n    this._textareaElement = this._elementRef.nativeElement as HTMLTextAreaElement;\n  }\n\n  /** Sets the minimum height of the textarea as determined by minRows. */\n  _setMinHeight(): void {\n    const minHeight =\n      this.minRows && this._cachedLineHeight ? `${this.minRows * this._cachedLineHeight}px` : null;\n\n    if (minHeight) {\n      this._textareaElement.style.minHeight = minHeight;\n    }\n  }\n\n  /** Sets the maximum height of the textarea as determined by maxRows. */\n  _setMaxHeight(): void {\n    const maxHeight =\n      this.maxRows && this._cachedLineHeight ? `${this.maxRows * this._cachedLineHeight}px` : null;\n\n    if (maxHeight) {\n      this._textareaElement.style.maxHeight = maxHeight;\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this._platform.isBrowser) {\n      // Remember the height which we started with in case autosizing is disabled\n      this._initialHeight = this._textareaElement.style.height;\n      this.resizeToFitContent();\n\n      this._ngZone.runOutsideAngular(() => {\n        const window = this._getWindow();\n\n        fromEvent(window, 'resize')\n          .pipe(auditTime(16), takeUntil(this._destroyed))\n          .subscribe(() => this.resizeToFitContent(true));\n\n        this._textareaElement.addEventListener('focus', this._handleFocusEvent);\n        this._textareaElement.addEventListener('blur', this._handleFocusEvent);\n      });\n\n      this._isViewInited = true;\n      this.resizeToFitContent(true);\n    }\n  }\n\n  ngOnDestroy() {\n    this._textareaElement.removeEventListener('focus', this._handleFocusEvent);\n    this._textareaElement.removeEventListener('blur', this._handleFocusEvent);\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /**\n   * Cache the height of a single-row textarea if it has not already been cached.\n   *\n   * We need to know how large a single \"row\" of a textarea is in order to apply minRows and\n   * maxRows. For the initial version, we will assume that the height of a single line in the\n   * textarea does not ever change.\n   */\n  private _cacheTextareaLineHeight(): void {\n    if (this._cachedLineHeight) {\n      return;\n    }\n\n    // Use a clone element because we have to override some styles.\n    let textareaClone = this._textareaElement.cloneNode(false) as HTMLTextAreaElement;\n    textareaClone.rows = 1;\n\n    // Use `position: absolute` so that this doesn't cause a browser layout and use\n    // `visibility: hidden` so that nothing is rendered. Clear any other styles that\n    // would affect the height.\n    textareaClone.style.position = 'absolute';\n    textareaClone.style.visibility = 'hidden';\n    textareaClone.style.border = 'none';\n    textareaClone.style.padding = '0';\n    textareaClone.style.height = '';\n    textareaClone.style.minHeight = '';\n    textareaClone.style.maxHeight = '';\n\n    // In Firefox it happens that textarea elements are always bigger than the specified amount\n    // of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.\n    // As a workaround that removes the extra space for the scrollbar, we can just set overflow\n    // to hidden. This ensures that there is no invalid calculation of the line height.\n    // See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654\n    textareaClone.style.overflow = 'hidden';\n\n    this._textareaElement.parentNode!.appendChild(textareaClone);\n    this._cachedLineHeight = textareaClone.clientHeight;\n    textareaClone.remove();\n\n    // Min and max heights have to be re-calculated if the cached line height changes\n    this._setMinHeight();\n    this._setMaxHeight();\n  }\n\n  private _measureScrollHeight(): number {\n    const element = this._textareaElement;\n    const previousMargin = element.style.marginBottom || '';\n    const isFirefox = this._platform.FIREFOX;\n    const needsMarginFiller = isFirefox && this._hasFocus;\n    const measuringClass = isFirefox\n      ? 'cdk-textarea-autosize-measuring-firefox'\n      : 'cdk-textarea-autosize-measuring';\n\n    // In some cases the page might move around while we're measuring the `textarea` on Firefox. We\n    // work around it by assigning a temporary margin with the same height as the `textarea` so that\n    // it occupies the same amount of space. See #23233.\n    if (needsMarginFiller) {\n      element.style.marginBottom = `${element.clientHeight}px`;\n    }\n\n    // Reset the textarea height to auto in order to shrink back to its default size.\n    // Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.\n    element.classList.add(measuringClass);\n    // The measuring class includes a 2px padding to workaround an issue with Chrome,\n    // so we account for that extra space here by subtracting 4 (2px top + 2px bottom).\n    const scrollHeight = element.scrollHeight - 4;\n    element.classList.remove(measuringClass);\n\n    if (needsMarginFiller) {\n      element.style.marginBottom = previousMargin;\n    }\n\n    return scrollHeight;\n  }\n\n  private _cacheTextareaPlaceholderHeight(): void {\n    if (!this._isViewInited || this._cachedPlaceholderHeight != undefined) {\n      return;\n    }\n    if (!this.placeholder) {\n      this._cachedPlaceholderHeight = 0;\n      return;\n    }\n\n    const value = this._textareaElement.value;\n\n    this._textareaElement.value = this._textareaElement.placeholder;\n    this._cachedPlaceholderHeight = this._measureScrollHeight();\n    this._textareaElement.value = value;\n  }\n\n  /** Handles `focus` and `blur` events. */\n  private _handleFocusEvent = (event: FocusEvent) => {\n    this._hasFocus = event.type === 'focus';\n  };\n\n  ngDoCheck() {\n    if (this._platform.isBrowser) {\n      this.resizeToFitContent();\n    }\n  }\n\n  /**\n   * Resize the textarea to fit its content.\n   * @param force Whether to force a height recalculation. By default the height will be\n   *    recalculated only if the value changed since the last call.\n   */\n  resizeToFitContent(force: boolean = false) {\n    // If autosizing is disabled, just skip everything else\n    if (!this._enabled) {\n      return;\n    }\n\n    this._cacheTextareaLineHeight();\n    this._cacheTextareaPlaceholderHeight();\n\n    // If we haven't determined the line-height yet, we know we're still hidden and there's no point\n    // in checking the height of the textarea.\n    if (!this._cachedLineHeight) {\n      return;\n    }\n\n    const textarea = this._elementRef.nativeElement as HTMLTextAreaElement;\n    const value = textarea.value;\n\n    // Only resize if the value or minRows have changed since these calculations can be expensive.\n    if (!force && this._minRows === this._previousMinRows && value === this._previousValue) {\n      return;\n    }\n\n    const scrollHeight = this._measureScrollHeight();\n    const height = Math.max(scrollHeight, this._cachedPlaceholderHeight || 0);\n\n    // Use the scrollHeight to know how large the textarea *would* be if fit its entire value.\n    textarea.style.height = `${height}px`;\n\n    this._ngZone.runOutsideAngular(() => {\n      if (typeof requestAnimationFrame !== 'undefined') {\n        requestAnimationFrame(() => this._scrollToCaretPosition(textarea));\n      } else {\n        setTimeout(() => this._scrollToCaretPosition(textarea));\n      }\n    });\n\n    this._previousValue = value;\n    this._previousMinRows = this._minRows;\n  }\n\n  /**\n   * Resets the textarea to its original size\n   */\n  reset() {\n    // Do not try to change the textarea, if the initialHeight has not been determined yet\n    // This might potentially remove styles when reset() is called before ngAfterViewInit\n    if (this._initialHeight !== undefined) {\n      this._textareaElement.style.height = this._initialHeight;\n    }\n  }\n\n  _noopInputHandler() {\n    // no-op handler that ensures we're running change detection on input events.\n  }\n\n  /** Access injected document if available or fallback to global document reference */\n  private _getDocument(): Document {\n    return this._document || document;\n  }\n\n  /** Use defaultView of injected document if available or fallback to global window reference */\n  private _getWindow(): Window {\n    const doc = this._getDocument();\n    return doc.defaultView || window;\n  }\n\n  /**\n   * Scrolls a textarea to the caret position. On Firefox resizing the textarea will\n   * prevent it from scrolling to the caret position. We need to re-set the selection\n   * in order for it to scroll to the proper position.\n   */\n  private _scrollToCaretPosition(textarea: HTMLTextAreaElement) {\n    const {selectionStart, selectionEnd} = textarea;\n\n    // IE will throw an \"Unspecified error\" if we try to set the selection range after the\n    // element has been removed from the DOM. Assert that the directive hasn't been destroyed\n    // between the time we requested the animation frame and when it was executed.\n    // Also note that we have to assert that the textarea is focused before we set the\n    // selection range. Setting the selection range on a non-focused textarea will cause\n    // it to receive focus on IE and Edge.\n    if (!this._destroyed.isStopped && this._hasFocus) {\n      textarea.setSelectionRange(selectionStart, selectionEnd);\n    }\n  }\n}\n"]}