@angular/material
Version:
Angular Material
618 lines • 49 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/material/datepicker/datepicker-input.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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 } from '@angular/cdk/coercion';
import { DOWN_ARROW } from '@angular/cdk/keycodes';
import { Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, Optional, Output, } from '@angular/core';
import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
import { DateAdapter, MAT_DATE_FORMATS } from '@angular/material/core';
import { MatFormField } from '@angular/material/form-field';
import { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';
import { Subscription } from 'rxjs';
import { MatDatepicker } from './datepicker';
import { createMissingDateImplError } from './datepicker-errors';
/**
* \@docs-private
* @type {?}
*/
export const MAT_DATEPICKER_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef((/**
* @return {?}
*/
() => MatDatepickerInput)),
multi: true
};
/**
* \@docs-private
* @type {?}
*/
export const MAT_DATEPICKER_VALIDATORS = {
provide: NG_VALIDATORS,
useExisting: forwardRef((/**
* @return {?}
*/
() => MatDatepickerInput)),
multi: true
};
/**
* An event used for datepicker input and change events. We don't always have access to a native
* input or change event because the event may have been triggered by the user clicking on the
* calendar popup. For consistency, we always use MatDatepickerInputEvent instead.
* @template D
*/
export class MatDatepickerInputEvent {
/**
* @param {?} target
* @param {?} targetElement
*/
constructor(target, targetElement) {
this.target = target;
this.targetElement = targetElement;
this.value = this.target.value;
}
}
if (false) {
/**
* The new value for the target datepicker input.
* @type {?}
*/
MatDatepickerInputEvent.prototype.value;
/**
* Reference to the datepicker input component that emitted the event.
* @type {?}
*/
MatDatepickerInputEvent.prototype.target;
/**
* Reference to the native input element associated with the datepicker input.
* @type {?}
*/
MatDatepickerInputEvent.prototype.targetElement;
}
/**
* Directive used to connect an input to a MatDatepicker.
* @template D
*/
export class MatDatepickerInput {
/**
* @param {?} _elementRef
* @param {?} _dateAdapter
* @param {?} _dateFormats
* @param {?} _formField
*/
constructor(_elementRef, _dateAdapter, _dateFormats, _formField) {
this._elementRef = _elementRef;
this._dateAdapter = _dateAdapter;
this._dateFormats = _dateFormats;
this._formField = _formField;
/**
* Emits when a `change` event is fired on this `<input>`.
*/
this.dateChange = new EventEmitter();
/**
* Emits when an `input` event is fired on this `<input>`.
*/
this.dateInput = new EventEmitter();
/**
* Emits when the value changes (either due to user input or programmatic change).
*/
this._valueChange = new EventEmitter();
/**
* Emits when the disabled state has changed
*/
this._disabledChange = new EventEmitter();
this._onTouched = (/**
* @return {?}
*/
() => { });
this._cvaOnChange = (/**
* @return {?}
*/
() => { });
this._validatorOnChange = (/**
* @return {?}
*/
() => { });
this._datepickerSubscription = Subscription.EMPTY;
this._localeSubscription = Subscription.EMPTY;
/**
* The form control validator for whether the input parses.
*/
this._parseValidator = (/**
* @return {?}
*/
() => {
return this._lastValueValid ?
null : { 'matDatepickerParse': { 'text': this._elementRef.nativeElement.value } };
});
/**
* The form control validator for the min date.
*/
this._minValidator = (/**
* @param {?} control
* @return {?}
*/
(control) => {
/** @type {?} */
const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));
return (!this.min || !controlValue ||
this._dateAdapter.compareDate(this.min, controlValue) <= 0) ?
null : { 'matDatepickerMin': { 'min': this.min, 'actual': controlValue } };
});
/**
* The form control validator for the max date.
*/
this._maxValidator = (/**
* @param {?} control
* @return {?}
*/
(control) => {
/** @type {?} */
const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));
return (!this.max || !controlValue ||
this._dateAdapter.compareDate(this.max, controlValue) >= 0) ?
null : { 'matDatepickerMax': { 'max': this.max, 'actual': controlValue } };
});
/**
* The form control validator for the date filter.
*/
this._filterValidator = (/**
* @param {?} control
* @return {?}
*/
(control) => {
/** @type {?} */
const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));
return !this._dateFilter || !controlValue || this._dateFilter(controlValue) ?
null : { 'matDatepickerFilter': true };
});
/**
* The combined form control validator for this input.
*/
this._validator = Validators.compose([this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator]);
/**
* Whether the last value set on the input was valid.
*/
this._lastValueValid = false;
if (!this._dateAdapter) {
throw createMissingDateImplError('DateAdapter');
}
if (!this._dateFormats) {
throw createMissingDateImplError('MAT_DATE_FORMATS');
}
// Update the displayed date when the locale changes.
this._localeSubscription = _dateAdapter.localeChanges.subscribe((/**
* @return {?}
*/
() => {
this.value = this.value;
}));
}
/**
* The datepicker that this input is associated with.
* @param {?} value
* @return {?}
*/
set matDatepicker(value) {
if (!value) {
return;
}
this._datepicker = value;
this._datepicker._registerInput(this);
this._datepickerSubscription.unsubscribe();
this._datepickerSubscription = this._datepicker._selectedChanged.subscribe((/**
* @param {?} selected
* @return {?}
*/
(selected) => {
this.value = selected;
this._cvaOnChange(selected);
this._onTouched();
this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
}));
}
/**
* Function that can be used to filter out dates within the datepicker.
* @param {?} value
* @return {?}
*/
set matDatepickerFilter(value) {
this._dateFilter = value;
this._validatorOnChange();
}
/**
* The value of the input.
* @return {?}
*/
get value() { return this._value; }
/**
* @param {?} value
* @return {?}
*/
set value(value) {
value = this._dateAdapter.deserialize(value);
this._lastValueValid = !value || this._dateAdapter.isValid(value);
value = this._getValidDateOrNull(value);
/** @type {?} */
const oldDate = this.value;
this._value = value;
this._formatValue(value);
if (!this._dateAdapter.sameDate(oldDate, value)) {
this._valueChange.emit(value);
}
}
/**
* The minimum valid date.
* @return {?}
*/
get min() { return this._min; }
/**
* @param {?} value
* @return {?}
*/
set min(value) {
this._min = this._getValidDateOrNull(this._dateAdapter.deserialize(value));
this._validatorOnChange();
}
/**
* The maximum valid date.
* @return {?}
*/
get max() { return this._max; }
/**
* @param {?} value
* @return {?}
*/
set max(value) {
this._max = this._getValidDateOrNull(this._dateAdapter.deserialize(value));
this._validatorOnChange();
}
/**
* Whether the datepicker-input is disabled.
* @return {?}
*/
get disabled() { return !!this._disabled; }
/**
* @param {?} value
* @return {?}
*/
set disabled(value) {
/** @type {?} */
const newValue = coerceBooleanProperty(value);
/** @type {?} */
const element = this._elementRef.nativeElement;
if (this._disabled !== newValue) {
this._disabled = newValue;
this._disabledChange.emit(newValue);
}
// We need to null check the `blur` method, because it's undefined during SSR.
if (newValue && element.blur) {
// Normally, native input elements automatically blur if they turn disabled. This behavior
// is problematic, because it would mean that it triggers another change detection cycle,
// which then causes a changed after checked error if the input element was focused before.
element.blur();
}
}
/**
* @return {?}
*/
ngOnDestroy() {
this._datepickerSubscription.unsubscribe();
this._localeSubscription.unsubscribe();
this._valueChange.complete();
this._disabledChange.complete();
}
/**
* \@docs-private
* @param {?} fn
* @return {?}
*/
registerOnValidatorChange(fn) {
this._validatorOnChange = fn;
}
/**
* \@docs-private
* @param {?} c
* @return {?}
*/
validate(c) {
return this._validator ? this._validator(c) : null;
}
/**
* @deprecated
* \@breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead
* @return {?}
*/
getPopupConnectionElementRef() {
return this.getConnectedOverlayOrigin();
}
/**
* Gets the element that the datepicker popup should be connected to.
* @return {?} The element to connect the popup to.
*/
getConnectedOverlayOrigin() {
return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;
}
// Implemented as part of ControlValueAccessor.
/**
* @param {?} value
* @return {?}
*/
writeValue(value) {
this.value = value;
}
// Implemented as part of ControlValueAccessor.
/**
* @param {?} fn
* @return {?}
*/
registerOnChange(fn) {
this._cvaOnChange = fn;
}
// Implemented as part of ControlValueAccessor.
/**
* @param {?} fn
* @return {?}
*/
registerOnTouched(fn) {
this._onTouched = fn;
}
// Implemented as part of ControlValueAccessor.
/**
* @param {?} isDisabled
* @return {?}
*/
setDisabledState(isDisabled) {
this.disabled = isDisabled;
}
/**
* @param {?} event
* @return {?}
*/
_onKeydown(event) {
/** @type {?} */
const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;
if (this._datepicker && isAltDownArrow && !this._elementRef.nativeElement.readOnly) {
this._datepicker.open();
event.preventDefault();
}
}
/**
* @param {?} value
* @return {?}
*/
_onInput(value) {
/** @type {?} */
const lastValueWasValid = this._lastValueValid;
/** @type {?} */
let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);
this._lastValueValid = !date || this._dateAdapter.isValid(date);
date = this._getValidDateOrNull(date);
if (!this._dateAdapter.sameDate(date, this._value)) {
this._value = date;
this._cvaOnChange(date);
this._valueChange.emit(date);
this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
}
else if (lastValueWasValid !== this._lastValueValid) {
this._validatorOnChange();
}
}
/**
* @return {?}
*/
_onChange() {
this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
}
/**
* Returns the palette used by the input's form field, if any.
* @return {?}
*/
_getThemePalette() {
return this._formField ? this._formField.color : undefined;
}
/**
* Handles blur events on the input.
* @return {?}
*/
_onBlur() {
// Reformat the input only if we have a valid value.
if (this.value) {
this._formatValue(this.value);
}
this._onTouched();
}
/**
* Formats a value and sets it on the input element.
* @private
* @param {?} value
* @return {?}
*/
_formatValue(value) {
this._elementRef.nativeElement.value =
value ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';
}
/**
* @private
* @param {?} obj The object to check.
* @return {?} The given object if it is both a date instance and valid, otherwise null.
*/
_getValidDateOrNull(obj) {
return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;
}
}
MatDatepickerInput.decorators = [
{ type: Directive, args: [{
selector: 'input[matDatepicker]',
providers: [
MAT_DATEPICKER_VALUE_ACCESSOR,
MAT_DATEPICKER_VALIDATORS,
{ provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput },
],
host: {
'[attr.aria-haspopup]': '_datepicker ? "dialog" : null',
'[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',
'[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',
'[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',
'[disabled]': 'disabled',
'(input)': '_onInput($event.target.value)',
'(change)': '_onChange()',
'(blur)': '_onBlur()',
'(keydown)': '_onKeydown($event)',
},
exportAs: 'matDatepickerInput',
},] }
];
/** @nocollapse */
MatDatepickerInput.ctorParameters = () => [
{ type: ElementRef },
{ type: DateAdapter, decorators: [{ type: Optional }] },
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },
{ type: MatFormField, decorators: [{ type: Optional }] }
];
MatDatepickerInput.propDecorators = {
matDatepicker: [{ type: Input }],
matDatepickerFilter: [{ type: Input }],
value: [{ type: Input }],
min: [{ type: Input }],
max: [{ type: Input }],
disabled: [{ type: Input }],
dateChange: [{ type: Output }],
dateInput: [{ type: Output }]
};
if (false) {
/** @type {?} */
MatDatepickerInput.ngAcceptInputType_value;
/** @type {?} */
MatDatepickerInput.ngAcceptInputType_disabled;
/** @type {?} */
MatDatepickerInput.prototype._datepicker;
/** @type {?} */
MatDatepickerInput.prototype._dateFilter;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._value;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._min;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._max;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._disabled;
/**
* Emits when a `change` event is fired on this `<input>`.
* @type {?}
*/
MatDatepickerInput.prototype.dateChange;
/**
* Emits when an `input` event is fired on this `<input>`.
* @type {?}
*/
MatDatepickerInput.prototype.dateInput;
/**
* Emits when the value changes (either due to user input or programmatic change).
* @type {?}
*/
MatDatepickerInput.prototype._valueChange;
/**
* Emits when the disabled state has changed
* @type {?}
*/
MatDatepickerInput.prototype._disabledChange;
/** @type {?} */
MatDatepickerInput.prototype._onTouched;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._cvaOnChange;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._validatorOnChange;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._datepickerSubscription;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._localeSubscription;
/**
* The form control validator for whether the input parses.
* @type {?}
* @private
*/
MatDatepickerInput.prototype._parseValidator;
/**
* The form control validator for the min date.
* @type {?}
* @private
*/
MatDatepickerInput.prototype._minValidator;
/**
* The form control validator for the max date.
* @type {?}
* @private
*/
MatDatepickerInput.prototype._maxValidator;
/**
* The form control validator for the date filter.
* @type {?}
* @private
*/
MatDatepickerInput.prototype._filterValidator;
/**
* The combined form control validator for this input.
* @type {?}
* @private
*/
MatDatepickerInput.prototype._validator;
/**
* Whether the last value set on the input was valid.
* @type {?}
* @private
*/
MatDatepickerInput.prototype._lastValueValid;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._elementRef;
/** @type {?} */
MatDatepickerInput.prototype._dateAdapter;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._dateFormats;
/**
* @type {?}
* @private
*/
MatDatepickerInput.prototype._formField;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-input.js","sourceRoot":"","sources":["../../../../../../src/material/datepicker/datepicker-input.ts"],"names":[],"mappings":";;;;;;;;;;;;AAQA,OAAO,EAAe,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAC1E,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AACjD,OAAO,EACL,SAAS,EACT,UAAU,EACV,YAAY,EACZ,UAAU,EACV,MAAM,EACN,KAAK,EAEL,QAAQ,EACR,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAGL,aAAa,EACb,iBAAiB,EAIjB,UAAU,GACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAC,WAAW,EAAE,gBAAgB,EAA+B,MAAM,wBAAwB,CAAC;AACnG,OAAO,EAAC,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAC,wBAAwB,EAAC,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAC,YAAY,EAAC,MAAM,MAAM,CAAC;AAClC,OAAO,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAC,0BAA0B,EAAC,MAAM,qBAAqB,CAAC;;;;;AAG/D,MAAM,OAAO,6BAA6B,GAAQ;IAChD,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,UAAU;;;IAAC,GAAG,EAAE,CAAC,kBAAkB,EAAC;IACjD,KAAK,EAAE,IAAI;CACZ;;;;;AAGD,MAAM,OAAO,yBAAyB,GAAQ;IAC5C,OAAO,EAAE,aAAa;IACtB,WAAW,EAAE,UAAU;;;IAAC,GAAG,EAAE,CAAC,kBAAkB,EAAC;IACjD,KAAK,EAAE,IAAI;CACZ;;;;;;;AAQD,MAAM,OAAO,uBAAuB;;;;;IAIlC,YAES,MAA6B,EAE7B,aAA0B;QAF1B,WAAM,GAAN,MAAM,CAAuB;QAE7B,kBAAa,GAAb,aAAa,CAAa;QACjC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IACjC,CAAC;CACF;;;;;;IATC,wCAAgB;;;;;IAId,yCAAoC;;;;;IAEpC,gDAAiC;;;;;;AA2BrC,MAAM,OAAO,kBAAkB;;;;;;;IAoJ7B,YACY,WAAyC,EAC9B,YAA4B,EACD,YAA4B,EACtD,UAAwB;QAHpC,gBAAW,GAAX,WAAW,CAA8B;QAC9B,iBAAY,GAAZ,YAAY,CAAgB;QACD,iBAAY,GAAZ,YAAY,CAAgB;QACtD,eAAU,GAAV,UAAU,CAAc;;;;QAhE7B,eAAU,GACzB,IAAI,YAAY,EAA8B,CAAC;;;;QAGhC,cAAS,GACxB,IAAI,YAAY,EAA8B,CAAC;;;;QAGnD,iBAAY,GAAG,IAAI,YAAY,EAAY,CAAC;;;;QAG5C,oBAAe,GAAG,IAAI,YAAY,EAAW,CAAC;QAE9C,eAAU;;;QAAG,GAAG,EAAE,GAAE,CAAC,EAAC;QAEd,iBAAY;;;QAAyB,GAAG,EAAE,GAAE,CAAC,EAAC;QAE9C,uBAAkB;;;QAAG,GAAG,EAAE,GAAE,CAAC,EAAC;QAE9B,4BAAuB,GAAG,YAAY,CAAC,KAAK,CAAC;QAE7C,wBAAmB,GAAG,YAAY,CAAC,KAAK,CAAC;;;;QAGzC,oBAAe;;;QAAgB,GAA4B,EAAE;YACnE,OAAO,IAAI,CAAC,eAAe,CAAC,CAAC;gBACzB,IAAI,CAAC,CAAC,CAAC,EAAC,oBAAoB,EAAE,EAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAC,EAAC,CAAC;QACpF,CAAC,EAAA;;;;QAGO,kBAAa;;;;QAAgB,CAAC,OAAwB,EAA2B,EAAE;;kBACnF,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3F,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,YAAY;gBAC9B,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC7D,IAAI,CAAC,CAAC,CAAC,EAAC,kBAAkB,EAAE,EAAC,KAAK,EAAE,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,YAAY,EAAC,EAAC,CAAC;QAC7E,CAAC,EAAA;;;;QAGO,kBAAa;;;;QAAgB,CAAC,OAAwB,EAA2B,EAAE;;kBACnF,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3F,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,YAAY;gBAC9B,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC7D,IAAI,CAAC,CAAC,CAAC,EAAC,kBAAkB,EAAE,EAAC,KAAK,EAAE,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,YAAY,EAAC,EAAC,CAAC;QAC7E,CAAC,EAAA;;;;QAGO,qBAAgB;;;;QAAgB,CAAC,OAAwB,EAA2B,EAAE;;kBACtF,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3F,OAAO,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC;gBACzE,IAAI,CAAC,CAAC,CAAC,EAAC,qBAAqB,EAAE,IAAI,EAAC,CAAC;QAC3C,CAAC,EAAA;;;;QAGO,eAAU,GACd,UAAU,CAAC,OAAO,CACd,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;;;;QAGvF,oBAAe,GAAG,KAAK,CAAC;QAO9B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,MAAM,0BAA0B,CAAC,aAAa,CAAC,CAAC;SACjD;QACD,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,MAAM,0BAA0B,CAAC,kBAAkB,CAAC,CAAC;SACtD;QAED,qDAAqD;QACrD,IAAI,CAAC,mBAAmB,GAAG,YAAY,CAAC,aAAa,CAAC,SAAS;;;QAAC,GAAG,EAAE;YACnE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAC1B,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;IAlKD,IACI,aAAa,CAAC,KAAuB;QACvC,IAAI,CAAC,KAAK,EAAE;YACV,OAAO;SACR;QAED,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE,CAAC;QAE3C,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,SAAS;;;;QAAC,CAAC,QAAW,EAAE,EAAE;YACzF,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAC5B,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;YACvF,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;QAC1F,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;IAID,IACI,mBAAmB,CAAC,KAAkC;QACxD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;;;;;IAID,IACI,KAAK,KAAe,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;IAC7C,IAAI,KAAK,CAAC,KAAe;QACvB,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,CAAC,eAAe,GAAG,CAAC,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAClE,KAAK,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;;cAClC,OAAO,GAAG,IAAI,CAAC,KAAK;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAEzB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE;YAC/C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC/B;IACH,CAAC;;;;;IAID,IACI,GAAG,KAAe,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;;;;;IACzC,IAAI,GAAG,CAAC,KAAe;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3E,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;;;;;IAID,IACI,GAAG,KAAe,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;;;;;IACzC,IAAI,GAAG,CAAC,KAAe;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3E,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;;;;;IAID,IACI,QAAQ,KAAc,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;;;;;IACpD,IAAI,QAAQ,CAAC,KAAc;;cACnB,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC;;cACvC,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa;QAE9C,IAAI,IAAI,CAAC,SAAS,KAAK,QAAQ,EAAE;YAC/B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC1B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACrC;QAED,8EAA8E;QAC9E,IAAI,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE;YAC5B,0FAA0F;YAC1F,yFAAyF;YACzF,2FAA2F;YAC3F,OAAO,CAAC,IAAI,EAAE,CAAC;SAChB;IACH,CAAC;;;;IAkFD,WAAW;QACT,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE,CAAC;QAC3C,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;QACvC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;;;;;;IAGD,yBAAyB,CAAC,EAAc;QACtC,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;IAC/B,CAAC;;;;;;IAGD,QAAQ,CAAC,CAAkB;QACzB,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACrD,CAAC;;;;;;IAMD,4BAA4B;QAC1B,OAAO,IAAI,CAAC,yBAAyB,EAAE,CAAC;IAC1C,CAAC;;;;;IAMD,yBAAyB;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,yBAAyB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;IAC1F,CAAC;;;;;;IAGD,UAAU,CAAC,KAAQ;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;;;;;;IAGD,gBAAgB,CAAC,EAAwB;QACvC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;IACzB,CAAC;;;;;;IAGD,iBAAiB,CAAC,EAAc;QAC9B,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;IACvB,CAAC;;;;;;IAGD,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;;;;;IAED,UAAU,CAAC,KAAoB;;cACvB,cAAc,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,KAAK,UAAU;QAEnE,IAAI,IAAI,CAAC,WAAW,IAAI,cAAc,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,EAAE;YAClF,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;YACxB,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;IACH,CAAC;;;;;IAED,QAAQ,CAAC,KAAa;;cACd,iBAAiB,GAAG,IAAI,CAAC,eAAe;;YAC1C,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC;QAC5E,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAChE,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAEtC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;YAClD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACnB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;SACxF;aAAM,IAAI,iBAAiB,KAAK,IAAI,CAAC,eAAe,EAAE;YACrD,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;IACH,CAAC;;;;IAED,SAAS;QACP,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC1F,CAAC;;;;;IAGD,gBAAgB;QACd,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7D,CAAC;;;;;IAGD,OAAO;QACL,oDAAoD;QACpD,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC/B;QAED,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;;;;;;;IAGO,YAAY,CAAC,KAAe;QAClC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK;YAChC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxF,CAAC;;;;;;IAMO,mBAAmB,CAAC,GAAQ;QAClC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IAChG,CAAC;;;YAvSF,SAAS,SAAC;gBACT,QAAQ,EAAE,sBAAsB;gBAChC,SAAS,EAAE;oBACT,6BAA6B;oBAC7B,yBAAyB;oBACzB,EAAC,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,kBAAkB,EAAC;iBACrE;gBACD,IAAI,EAAE;oBACJ,sBAAsB,EAAE,+BAA+B;oBACvD,kBAAkB,EAAE,iDAAiD;oBACrE,YAAY,EAAE,0CAA0C;oBACxD,YAAY,EAAE,0CAA0C;oBACxD,YAAY,EAAE,UAAU;oBACxB,SAAS,EAAE,+BAA+B;oBAC1C,UAAU,EAAE,aAAa;oBACzB,QAAQ,EAAE,WAAW;oBACrB,WAAW,EAAE,oBAAoB;iBAClC;gBACD,QAAQ,EAAE,oBAAoB;aAC/B;;;;YAhFC,UAAU;YAmBJ,WAAW,uBAoNZ,QAAQ;4CACR,QAAQ,YAAI,MAAM,SAAC,gBAAgB;YApNlC,YAAY,uBAqNb,QAAQ;;;4BAtJZ,KAAK;kCAqBL,KAAK;oBAQL,KAAK;kBAiBL,KAAK;kBASL,KAAK;uBASL,KAAK;yBAsBL,MAAM;wBAIN,MAAM;;;;IA2LP,2CAAoC;;IACpC,8CAAgD;;IApQhD,yCAA8B;;IAQ9B,yCAAyC;;;;;IAiBzC,oCAAyB;;;;;IASzB,kCAAuB;;;;;IASvB,kCAAuB;;;;;IAsBvB,uCAA2B;;;;;IAG3B,wCACmD;;;;;IAGnD,uCACmD;;;;;IAGnD,0CAA4C;;;;;IAG5C,6CAA8C;;IAE9C,wCAAsB;;;;;IAEtB,0CAAsD;;;;;IAEtD,gDAAsC;;;;;IAEtC,qDAAqD;;;;;IAErD,iDAAiD;;;;;;IAGjD,6CAGC;;;;;;IAGD,2CAKC;;;;;;IAGD,2CAKC;;;;;;IAGD,8CAIC;;;;;;IAGD,wCAE+F;;;;;;IAG/F,6CAAgC;;;;;IAG5B,yCAAiD;;IACjD,0CAA+C;;;;;IAC/C,0CAA0E;;;;;IAC1E,wCAA4C","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 {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {DOWN_ARROW} from '@angular/cdk/keycodes';\nimport {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator,\n  ValidatorFn,\n  Validators,\n} from '@angular/forms';\nimport {DateAdapter, MAT_DATE_FORMATS, MatDateFormats, ThemePalette} from '@angular/material/core';\nimport {MatFormField} from '@angular/material/form-field';\nimport {MAT_INPUT_VALUE_ACCESSOR} from '@angular/material/input';\nimport {Subscription} from 'rxjs';\nimport {MatDatepicker} from './datepicker';\nimport {createMissingDateImplError} from './datepicker-errors';\n\n/** @docs-private */\nexport const MAT_DATEPICKER_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => MatDatepickerInput),\n  multi: true\n};\n\n/** @docs-private */\nexport const MAT_DATEPICKER_VALIDATORS: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MatDatepickerInput),\n  multi: true\n};\n\n\n/**\n * An event used for datepicker input and change events. We don't always have access to a native\n * input or change event because the event may have been triggered by the user clicking on the\n * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.\n */\nexport class MatDatepickerInputEvent<D> {\n  /** The new value for the target datepicker input. */\n  value: D | null;\n\n  constructor(\n    /** Reference to the datepicker input component that emitted the event. */\n    public target: MatDatepickerInput<D>,\n    /** Reference to the native input element associated with the datepicker input. */\n    public targetElement: HTMLElement) {\n    this.value = this.target.value;\n  }\n}\n\n\n/** Directive used to connect an input to a MatDatepicker. */\n@Directive({\n  selector: 'input[matDatepicker]',\n  providers: [\n    MAT_DATEPICKER_VALUE_ACCESSOR,\n    MAT_DATEPICKER_VALIDATORS,\n    {provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput},\n  ],\n  host: {\n    '[attr.aria-haspopup]': '_datepicker ? \"dialog\" : null',\n    '[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',\n    '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',\n    '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',\n    '[disabled]': 'disabled',\n    '(input)': '_onInput($event.target.value)',\n    '(change)': '_onChange()',\n    '(blur)': '_onBlur()',\n    '(keydown)': '_onKeydown($event)',\n  },\n  exportAs: 'matDatepickerInput',\n})\nexport class MatDatepickerInput<D> implements ControlValueAccessor, OnDestroy, Validator {\n  /** The datepicker that this input is associated with. */\n  @Input()\n  set matDatepicker(value: MatDatepicker<D>) {\n    if (!value) {\n      return;\n    }\n\n    this._datepicker = value;\n    this._datepicker._registerInput(this);\n    this._datepickerSubscription.unsubscribe();\n\n    this._datepickerSubscription = this._datepicker._selectedChanged.subscribe((selected: D) => {\n      this.value = selected;\n      this._cvaOnChange(selected);\n      this._onTouched();\n      this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n      this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n    });\n  }\n  _datepicker: MatDatepicker<D>;\n\n  /** Function that can be used to filter out dates within the datepicker. */\n  @Input()\n  set matDatepickerFilter(value: (date: D | null) => boolean) {\n    this._dateFilter = value;\n    this._validatorOnChange();\n  }\n  _dateFilter: (date: D | null) => boolean;\n\n  /** The value of the input. */\n  @Input()\n  get value(): D | null { return this._value; }\n  set value(value: D | null) {\n    value = this._dateAdapter.deserialize(value);\n    this._lastValueValid = !value || this._dateAdapter.isValid(value);\n    value = this._getValidDateOrNull(value);\n    const oldDate = this.value;\n    this._value = value;\n    this._formatValue(value);\n\n    if (!this._dateAdapter.sameDate(oldDate, value)) {\n      this._valueChange.emit(value);\n    }\n  }\n  private _value: D | null;\n\n  /** The minimum valid date. */\n  @Input()\n  get min(): D | null { return this._min; }\n  set min(value: D | null) {\n    this._min = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    this._validatorOnChange();\n  }\n  private _min: D | null;\n\n  /** The maximum valid date. */\n  @Input()\n  get max(): D | null { return this._max; }\n  set max(value: D | null) {\n    this._max = this._getValidDateOrNull(this._dateAdapter.deserialize(value));\n    this._validatorOnChange();\n  }\n  private _max: D | null;\n\n  /** Whether the datepicker-input is disabled. */\n  @Input()\n  get disabled(): boolean { return !!this._disabled; }\n  set disabled(value: boolean) {\n    const newValue = coerceBooleanProperty(value);\n    const element = this._elementRef.nativeElement;\n\n    if (this._disabled !== newValue) {\n      this._disabled = newValue;\n      this._disabledChange.emit(newValue);\n    }\n\n    // We need to null check the `blur` method, because it's undefined during SSR.\n    if (newValue && element.blur) {\n      // Normally, native input elements automatically blur if they turn disabled. This behavior\n      // is problematic, because it would mean that it triggers another change detection cycle,\n      // which then causes a changed after checked error if the input element was focused before.\n      element.blur();\n    }\n  }\n  private _disabled: boolean;\n\n  /** Emits when a `change` event is fired on this `<input>`. */\n  @Output() readonly dateChange: EventEmitter<MatDatepickerInputEvent<D>> =\n      new EventEmitter<MatDatepickerInputEvent<D>>();\n\n  /** Emits when an `input` event is fired on this `<input>`. */\n  @Output() readonly dateInput: EventEmitter<MatDatepickerInputEvent<D>> =\n      new EventEmitter<MatDatepickerInputEvent<D>>();\n\n  /** Emits when the value changes (either due to user input or programmatic change). */\n  _valueChange = new EventEmitter<D | null>();\n\n  /** Emits when the disabled state has changed */\n  _disabledChange = new EventEmitter<boolean>();\n\n  _onTouched = () => {};\n\n  private _cvaOnChange: (value: any) => void = () => {};\n\n  private _validatorOnChange = () => {};\n\n  private _datepickerSubscription = Subscription.EMPTY;\n\n  private _localeSubscription = Subscription.EMPTY;\n\n  /** The form control validator for whether the input parses. */\n  private _parseValidator: ValidatorFn = (): ValidationErrors | null => {\n    return this._lastValueValid ?\n        null : {'matDatepickerParse': {'text': this._elementRef.nativeElement.value}};\n  }\n\n  /** The form control validator for the min date. */\n  private _minValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n    const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n    return (!this.min || !controlValue ||\n        this._dateAdapter.compareDate(this.min, controlValue) <= 0) ?\n        null : {'matDatepickerMin': {'min': this.min, 'actual': controlValue}};\n  }\n\n  /** The form control validator for the max date. */\n  private _maxValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n    const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n    return (!this.max || !controlValue ||\n        this._dateAdapter.compareDate(this.max, controlValue) >= 0) ?\n        null : {'matDatepickerMax': {'max': this.max, 'actual': controlValue}};\n  }\n\n  /** The form control validator for the date filter. */\n  private _filterValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n    const controlValue = this._getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n    return !this._dateFilter || !controlValue || this._dateFilter(controlValue) ?\n        null : {'matDatepickerFilter': true};\n  }\n\n  /** The combined form control validator for this input. */\n  private _validator: ValidatorFn | null =\n      Validators.compose(\n          [this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator]);\n\n  /** Whether the last value set on the input was valid. */\n  private _lastValueValid = false;\n\n  constructor(\n      private _elementRef: ElementRef<HTMLInputElement>,\n      @Optional() public _dateAdapter: DateAdapter<D>,\n      @Optional() @Inject(MAT_DATE_FORMATS) private _dateFormats: MatDateFormats,\n      @Optional() private _formField: MatFormField) {\n    if (!this._dateAdapter) {\n      throw createMissingDateImplError('DateAdapter');\n    }\n    if (!this._dateFormats) {\n      throw createMissingDateImplError('MAT_DATE_FORMATS');\n    }\n\n    // Update the displayed date when the locale changes.\n    this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => {\n      this.value = this.value;\n    });\n  }\n\n  ngOnDestroy() {\n    this._datepickerSubscription.unsubscribe();\n    this._localeSubscription.unsubscribe();\n    this._valueChange.complete();\n    this._disabledChange.complete();\n  }\n\n  /** @docs-private */\n  registerOnValidatorChange(fn: () => void): void {\n    this._validatorOnChange = fn;\n  }\n\n  /** @docs-private */\n  validate(c: AbstractControl): ValidationErrors | null {\n    return this._validator ? this._validator(c) : null;\n  }\n\n  /**\n   * @deprecated\n   * @breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead\n   */\n  getPopupConnectionElementRef(): ElementRef {\n    return this.getConnectedOverlayOrigin();\n  }\n\n  /**\n   * Gets the element that the datepicker popup should be connected to.\n   * @return The element to connect the popup to.\n   */\n  getConnectedOverlayOrigin(): ElementRef {\n    return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  writeValue(value: D): void {\n    this.value = value;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  registerOnChange(fn: (value: any) => void): void {\n    this._cvaOnChange = fn;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;\n\n    if (this._datepicker && isAltDownArrow && !this._elementRef.nativeElement.readOnly) {\n      this._datepicker.open();\n      event.preventDefault();\n    }\n  }\n\n  _onInput(value: string) {\n    const lastValueWasValid = this._lastValueValid;\n    let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);\n    this._lastValueValid = !date || this._dateAdapter.isValid(date);\n    date = this._getValidDateOrNull(date);\n\n    if (!this._dateAdapter.sameDate(date, this._value)) {\n      this._value = date;\n      this._cvaOnChange(date);\n      this._valueChange.emit(date);\n      this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n    } else if (lastValueWasValid !== this._lastValueValid) {\n      this._validatorOnChange();\n    }\n  }\n\n  _onChange() {\n    this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n  }\n\n  /** Returns the palette used by the input's form field, if any. */\n  _getThemePalette(): ThemePalette {\n    return this._formField ? this._formField.color : undefined;\n  }\n\n  /** Handles blur events on the input. */\n  _onBlur() {\n    // Reformat the input only if we have a valid value.\n    if (this.value) {\n      this._formatValue(this.value);\n    }\n\n    this._onTouched();\n  }\n\n  /** Formats a value and sets it on the input element. */\n  private _formatValue(value: D | null) {\n    this._elementRef.nativeElement.value =\n        value ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';\n  }\n\n  /**\n   * @param obj The object to check.\n   * @returns The given object if it is both a date instance and valid, otherwise null.\n   */\n  private _getValidDateOrNull(obj: any): D | null {\n    return (this._dateAdapter.isDateInstance(obj) && this._dateAdapter.isValid(obj)) ? obj : null;\n  }\n\n  // Accept `any` to avoid conflicts with other directives on `<input>` that\n  // may accept different types.\n  static ngAcceptInputType_value: any;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}