@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm5/shared/gipi-components/datepicker/mat-datepicker/date-range-input-parts.js

@@ -0,0 +1,339 @@
+/**
+ * @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 { __decorate, __extends, __metadata, __param, __read, __spread } from "tslib";
+import { BACKSPACE } from '@angular/cdk/keycodes';
+import { Directive, DoCheck, ElementRef, Inject, InjectFlags, InjectionToken, Injector, OnInit, Optional, Type, } from '@angular/core';
+import { AbstractControl, FormGroupDirective, NG_VALIDATORS, NG_VALUE_ACCESSOR, NgControl, NgForm, ValidationErrors, ValidatorFn, Validators, } from '@angular/forms';
+import { CanUpdateErrorState, CanUpdateErrorStateCtor, ErrorStateMatcher, MAT_DATE_FORMATS, MatDateFormats, mixinErrorState, } from '@angular/material/core';
+import { DateRange } from './date-selection-model';
+import { MatDatepickerInputBase } from './datepicker-input-base';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/**
+ * Used to provide the date range input wrapper component
+ * to the parts without circular dependencies.
+ */
+export var MAT_DATE_RANGE_INPUT_PARENT = new InjectionToken('MAT_DATE_RANGE_INPUT_PARENT');
+/**
+ * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.
+ */
+var MatDateRangeInputPartBase = /** @class */ (function (_super) {
+    __extends(MatDateRangeInputPartBase, _super);
+    function MatDateRangeInputPartBase(_rangeInput, elementRef, _defaultErrorStateMatcher, _injector, _parentForm, _parentFormGroup, dateAdapter, dateFormats) {
+        var _this = _super.call(this, elementRef, dateAdapter, dateFormats) || this;
+        _this._rangeInput = _rangeInput;
+        _this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        _this._injector = _injector;
+        _this._parentForm = _parentForm;
+        _this._parentFormGroup = _parentFormGroup;
+        _this._outsideValueChanged = function () {
+            // Whenever the value changes outside the input we need to revalidate, because
+            // the validation state of each of the inputs depends on the other one.
+            _this._validatorOnChange();
+        };
+        return _this;
+    }
+    MatDateRangeInputPartBase.prototype.ngOnInit = function () {
+        // We need the date input to provide itself as a `ControlValueAccessor` and a `Validator`, while
+        // injecting its `NgControl` so that the error state is handled correctly. This introduces a
+        // circular dependency, because both `ControlValueAccessor` and `Validator` depend on the input
+        // itself. Usually we can work around it for the CVA, but there's no API to do it for the
+        // validator. We work around it here by injecting the `NgControl` in `ngOnInit`, after
+        // everything has been resolved.
+        var ngControl = this._injector.get(NgControl, null, InjectFlags.Self);
+        this._injector.get(NgControl, null);
+        if (ngControl) {
+            this.ngControl = ngControl;
+        }
+    };
+    MatDateRangeInputPartBase.prototype.ngDoCheck = function () {
+        if (this.ngControl) {
+            // We need to re-evaluate this on every change detection cycle, because there are some
+            // error triggers that we can't subscribe to (e.g. parent form submissions). This means
+            // that whatever logic is in here has to be super lean or we risk destroying the performance.
+            this.updateErrorState();
+        }
+    };
+    /** Gets whether the input is empty. */
+    MatDateRangeInputPartBase.prototype.isEmpty = function () {
+        return this._elementRef.nativeElement.value.length === 0;
+    };
+    /** Gets the placeholder of the input. */
+    MatDateRangeInputPartBase.prototype._getPlaceholder = function () {
+        return this._elementRef.nativeElement.placeholder;
+    };
+    /** Focuses the input. */
+    MatDateRangeInputPartBase.prototype.focus = function () {
+        this._elementRef.nativeElement.focus();
+    };
+    /** Handles `input` events on the input element. */
+    MatDateRangeInputPartBase.prototype._onInput = function (value) {
+        _super.prototype._onInput.call(this, value);
+        this._rangeInput._handleChildValueChange();
+    };
+    /** Opens the datepicker associated with the input. */
+    MatDateRangeInputPartBase.prototype._openPopup = function () {
+        this._rangeInput._openDatepicker();
+    };
+    /** Gets the minimum date from the range input. */
+    MatDateRangeInputPartBase.prototype._getMinDate = function () {
+        return this._rangeInput.min;
+    };
+    /** Gets the maximum date from the range input. */
+    MatDateRangeInputPartBase.prototype._getMaxDate = function () {
+        return this._rangeInput.max;
+    };
+    /** Gets the date filter function from the range input. */
+    MatDateRangeInputPartBase.prototype._getDateFilter = function () {
+        return this._rangeInput.dateFilter;
+    };
+    MatDateRangeInputPartBase.prototype._parentDisabled = function () {
+        return this._rangeInput._groupDisabled;
+    };
+    MatDateRangeInputPartBase.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_INPUT_PARENT,] }] },
+        { type: ElementRef },
+        { type: ErrorStateMatcher },
+        { type: Injector },
+        { type: NgForm, decorators: [{ type: Optional }] },
+        { type: FormGroupDirective, decorators: [{ type: Optional }] },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] }
+    ]; };
+    MatDateRangeInputPartBase = __decorate([
+        Directive({}),
+        __param(0, Inject(MAT_DATE_RANGE_INPUT_PARENT)),
+        __param(4, Optional()),
+        __param(5, Optional()),
+        __param(6, Optional()),
+        __param(7, Optional()), __param(7, Inject(MAT_DATE_FORMATS)),
+        __metadata("design:paramtypes", [Object, ElementRef,
+            ErrorStateMatcher,
+            Injector,
+            NgForm,
+            FormGroupDirective,
+            DateAdapter, Object])
+    ], MatDateRangeInputPartBase);
+    return MatDateRangeInputPartBase;
+}(MatDatepickerInputBase));
+var _MatDateRangeInputBase = 
+// Needs to be `as any`, because the base class is abstract.
+mixinErrorState(MatDateRangeInputPartBase);
+/** Input for entering the start date in a `mat-date-range-input`. */
+var MatStartDate = /** @class */ (function (_super) {
+    __extends(MatStartDate, _super);
+    function MatStartDate(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) {
+        var _this = 
+        // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to
+        // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this
+        // constructor once ViewEngine is removed.
+        _super.call(this, rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) || this;
+        /** Validator that checks that the start date isn't after the end date. */
+        _this._startValidator = function (control) {
+            var start = _this._dateAdapter.getValidDateOrNull(_this._dateAdapter.deserialize(control.value));
+            var end = _this._model ? _this._model.selection.end : null;
+            return (!start || !end || _this._dateAdapter.compareDate(start, end) <= 0) ? null : { 'matStartDateInvalid': { 'end': end, 'actual': start } };
+        };
+        _this._validator = Validators.compose(__spread(_super.prototype._getValidators.call(_this), [_this._startValidator]));
+        _this._canEmitChangeEvent = function (event) {
+            return event.source !== _this._rangeInput._endInput;
+        };
+        return _this;
+    }
+    MatStartDate_1 = MatStartDate;
+    MatStartDate.prototype.ngOnInit = function () {
+        // Normally this happens automatically, but it seems to break if not added explicitly when all
+        // of the criteria below are met:
+        // 1) The class extends a TS mixin.
+        // 2) The application is running in ViewEngine.
+        // 3) The application is being transpiled through tsickle.
+        // This can be removed once google3 is completely migrated to Ivy.
+        _super.prototype.ngOnInit.call(this);
+    };
+    MatStartDate.prototype.ngDoCheck = function () {
+        // Normally this happens automatically, but it seems to break if not added explicitly when all
+        // of the criteria below are met:
+        // 1) The class extends a TS mixin.
+        // 2) The application is running in ViewEngine.
+        // 3) The application is being transpiled through tsickle.
+        // This can be removed once google3 is completely migrated to Ivy.
+        _super.prototype.ngDoCheck.call(this);
+    };
+    MatStartDate.prototype._getValueFromModel = function (modelValue) {
+        return modelValue.start;
+    };
+    MatStartDate.prototype._assignValueToModel = function (value) {
+        if (this._model) {
+            var range = new DateRange(value, this._model.selection.end);
+            this._model.updateSelection(range, this);
+            this._cvaOnChange(value);
+        }
+    };
+    MatStartDate.prototype._formatValue = function (value) {
+        _super.prototype._formatValue.call(this, value);
+        // Any time the input value is reformatted we need to tell the parent.
+        this._rangeInput._handleChildValueChange();
+    };
+    /** Gets the value that should be used when mirroring the input's size. */
+    MatStartDate.prototype.getMirrorValue = function () {
+        var element = this._elementRef.nativeElement;
+        var value = element.value;
+        return value.length > 0 ? value : element.placeholder;
+    };
+    var MatStartDate_1;
+    MatStartDate.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_INPUT_PARENT,] }] },
+        { type: ElementRef },
+        { type: ErrorStateMatcher },
+        { type: Injector },
+        { type: NgForm, decorators: [{ type: Optional }] },
+        { type: FormGroupDirective, decorators: [{ type: Optional }] },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] }
+    ]; };
+    MatStartDate = MatStartDate_1 = __decorate([
+        Directive({
+            selector: 'input[gipiMatStartDate]',
+            host: {
+                'class': 'mat-start-date mat-date-range-input-inner',
+                '[disabled]': 'disabled',
+                '(input)': '_onInput($event.target.value)',
+                '(change)': '_onChange()',
+                '(keydown)': '_onKeydown($event)',
+                '[attr.id]': '_rangeInput.id',
+                '[attr.aria-haspopup]': '_rangeInput.rangePicker ? "dialog" : null',
+                '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',
+                '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',
+                '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',
+                '(blur)': '_onBlur()',
+                'type': 'text',
+            },
+            providers: [
+                { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate_1, multi: true },
+                { provide: NG_VALIDATORS, useExisting: MatStartDate_1, multi: true }
+            ]
+        }),
+        __param(0, Inject(MAT_DATE_RANGE_INPUT_PARENT)),
+        __param(4, Optional()),
+        __param(5, Optional()),
+        __param(6, Optional()),
+        __param(7, Optional()), __param(7, Inject(MAT_DATE_FORMATS)),
+        __metadata("design:paramtypes", [Object, ElementRef,
+            ErrorStateMatcher,
+            Injector,
+            NgForm,
+            FormGroupDirective,
+            DateAdapter, Object])
+    ], MatStartDate);
+    return MatStartDate;
+}(_MatDateRangeInputBase));
+export { MatStartDate };
+/** Input for entering the end date in a `mat-date-range-input`. */
+var MatEndDate = /** @class */ (function (_super) {
+    __extends(MatEndDate, _super);
+    function MatEndDate(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) {
+        var _this = 
+        // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to
+        // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this
+        // constructor once ViewEngine is removed.
+        _super.call(this, rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats) || this;
+        /** Validator that checks that the end date isn't before the start date. */
+        _this._endValidator = function (control) {
+            var end = _this._dateAdapter.getValidDateOrNull(_this._dateAdapter.deserialize(control.value));
+            var start = _this._model ? _this._model.selection.start : null;
+            return (!end || !start || _this._dateAdapter.compareDate(end, start) >= 0) ? null : { 'matEndDateInvalid': { 'start': start, 'actual': end } };
+        };
+        _this._validator = Validators.compose(__spread(_super.prototype._getValidators.call(_this), [_this._endValidator]));
+        _this._canEmitChangeEvent = function (event) {
+            return event.source !== _this._rangeInput._startInput;
+        };
+        return _this;
+    }
+    MatEndDate_1 = MatEndDate;
+    MatEndDate.prototype.ngOnInit = function () {
+        // Normally this happens automatically, but it seems to break if not added explicitly when all
+        // of the criteria below are met:
+        // 1) The class extends a TS mixin.
+        // 2) The application is running in ViewEngine.
+        // 3) The application is being transpiled through tsickle.
+        // This can be removed once google3 is completely migrated to Ivy.
+        _super.prototype.ngOnInit.call(this);
+    };
+    MatEndDate.prototype.ngDoCheck = function () {
+        // Normally this happens automatically, but it seems to break if not added explicitly when all
+        // of the criteria below are met:
+        // 1) The class extends a TS mixin.
+        // 2) The application is running in ViewEngine.
+        // 3) The application is being transpiled through tsickle.
+        // This can be removed once google3 is completely migrated to Ivy.
+        _super.prototype.ngDoCheck.call(this);
+    };
+    MatEndDate.prototype._getValueFromModel = function (modelValue) {
+        return modelValue.end;
+    };
+    MatEndDate.prototype._assignValueToModel = function (value) {
+        if (this._model) {
+            var range = new DateRange(this._model.selection.start, value);
+            this._model.updateSelection(range, this);
+            this._cvaOnChange(value);
+        }
+    };
+    MatEndDate.prototype._onKeydown = function (event) {
+        // If the user is pressing backspace on an empty end input, move focus back to the start.
+        if (event.keyCode === BACKSPACE && !this._elementRef.nativeElement.value) {
+            this._rangeInput._startInput.focus();
+        }
+        _super.prototype._onKeydown.call(this, event);
+    };
+    var MatEndDate_1;
+    MatEndDate.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_INPUT_PARENT,] }] },
+        { type: ElementRef },
+        { type: ErrorStateMatcher },
+        { type: Injector },
+        { type: NgForm, decorators: [{ type: Optional }] },
+        { type: FormGroupDirective, decorators: [{ type: Optional }] },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] }
+    ]; };
+    MatEndDate = MatEndDate_1 = __decorate([
+        Directive({
+            selector: 'input[gipiMatEndDate]',
+            host: {
+                'class': 'mat-end-date mat-date-range-input-inner',
+                '[disabled]': 'disabled',
+                '(input)': '_onInput($event.target.value)',
+                '(change)': '_onChange()',
+                '(keydown)': '_onKeydown($event)',
+                '[attr.aria-haspopup]': '_rangeInput.rangePicker ? "dialog" : null',
+                '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',
+                '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',
+                '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',
+                '(blur)': '_onBlur()',
+                'type': 'text',
+            },
+            providers: [
+                { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate_1, multi: true },
+                { provide: NG_VALIDATORS, useExisting: MatEndDate_1, multi: true }
+            ]
+        }),
+        __param(0, Inject(MAT_DATE_RANGE_INPUT_PARENT)),
+        __param(4, Optional()),
+        __param(5, Optional()),
+        __param(6, Optional()),
+        __param(7, Optional()), __param(7, Inject(MAT_DATE_FORMATS)),
+        __metadata("design:paramtypes", [Object, ElementRef,
+            ErrorStateMatcher,
+            Injector,
+            NgForm,
+            FormGroupDirective,
+            DateAdapter, Object])
+    ], MatEndDate);
+    return MatEndDate;
+}(_MatDateRangeInputBase));
+export { MatEndDate };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-input-parts.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/date-range-input-parts.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 { BACKSPACE } from '@angular/cdk/keycodes';\nimport { Directive, DoCheck, ElementRef, Inject, InjectFlags, InjectionToken, Injector, OnInit, Optional, Type, } from '@angular/core';\nimport { AbstractControl, FormGroupDirective, NG_VALIDATORS, NG_VALUE_ACCESSOR, NgControl, NgForm, ValidationErrors, ValidatorFn, Validators, } from '@angular/forms';\nimport { CanUpdateErrorState, CanUpdateErrorStateCtor, ErrorStateMatcher, MAT_DATE_FORMATS, MatDateFormats, mixinErrorState, } from '@angular/material/core';\nimport { DateRange, DateSelectionModelChange } from './date-selection-model';\nimport { DateFilterFn, MatDatepickerInputBase } from './datepicker-input-base';\nimport { DateAdapter } from './shared/adapter/date-adapter';\n\n/** Parent component that should be wrapped around `MatStartDate` and `MatEndDate`. */\nexport interface MatDateRangeInputParent<D> {\n    id: string;\n    min: D | null;\n    max: D | null;\n    dateFilter: DateFilterFn<D>;\n    rangePicker: {\n        opened: boolean;\n        id: string;\n    };\n    _startInput: MatDateRangeInputPartBase<D>;\n    _endInput: MatDateRangeInputPartBase<D>;\n    _groupDisabled: boolean;\n    _handleChildValueChange(): void;\n    _openDatepicker(): void;\n}\n\n/**\n * Used to provide the date range input wrapper component\n * to the parts without circular dependencies.\n */\nexport const MAT_DATE_RANGE_INPUT_PARENT = new InjectionToken<MatDateRangeInputParent<unknown>>('MAT_DATE_RANGE_INPUT_PARENT');\n\n/**\n * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.\n */\n@Directive({})\nabstract class MatDateRangeInputPartBase<D> extends MatDatepickerInputBase<DateRange<D>> implements OnInit, DoCheck {\n\n    /** @docs-private */\n    ngControl: NgControl;\n\n    /** @docs-private */\n    abstract updateErrorState(): void;\n\n    protected abstract _validator: ValidatorFn | null;\n    protected abstract _assignValueToModel(value: D | null): void;\n    protected abstract _getValueFromModel(modelValue: DateRange<D>): D | null;\n\n    constructor(\n        @Inject(MAT_DATE_RANGE_INPUT_PARENT) public _rangeInput: MatDateRangeInputParent<D>,\n        elementRef: ElementRef<HTMLInputElement>,\n        public _defaultErrorStateMatcher: ErrorStateMatcher,\n        private _injector: Injector,\n        @Optional() public _parentForm: NgForm,\n        @Optional() public _parentFormGroup: FormGroupDirective,\n        @Optional() dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats) {\n        super(elementRef, dateAdapter, dateFormats);\n    }\n\n    ngOnInit() {\n        // We need the date input to provide itself as a `ControlValueAccessor` and a `Validator`, while\n        // injecting its `NgControl` so that the error state is handled correctly. This introduces a\n        // circular dependency, because both `ControlValueAccessor` and `Validator` depend on the input\n        // itself. Usually we can work around it for the CVA, but there's no API to do it for the\n        // validator. We work around it here by injecting the `NgControl` in `ngOnInit`, after\n        // everything has been resolved.\n        const ngControl = this._injector.get<NgControl>(NgControl as Type<NgControl>, null, InjectFlags.Self);\n\n        this._injector.get(NgControl, null)\n\n        if (ngControl) {\n            this.ngControl = ngControl;\n        }\n    }\n\n    ngDoCheck() {\n        if (this.ngControl) {\n            // We need to re-evaluate this on every change detection cycle, because there are some\n            // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n            // that whatever logic is in here has to be super lean or we risk destroying the performance.\n            this.updateErrorState();\n        }\n    }\n\n    /** Gets whether the input is empty. */\n    isEmpty(): boolean {\n        return this._elementRef.nativeElement.value.length === 0;\n    }\n\n    /** Gets the placeholder of the input. */\n    _getPlaceholder() {\n        return this._elementRef.nativeElement.placeholder;\n    }\n\n    /** Focuses the input. */\n    focus(): void {\n        this._elementRef.nativeElement.focus();\n    }\n\n    /** Handles `input` events on the input element. */\n    _onInput(value: string) {\n        super._onInput(value);\n        this._rangeInput._handleChildValueChange();\n    }\n\n    /** Opens the datepicker associated with the input. */\n    protected _openPopup(): void {\n        this._rangeInput._openDatepicker();\n    }\n\n    /** Gets the minimum date from the range input. */\n    _getMinDate() {\n        return this._rangeInput.min;\n    }\n\n    /** Gets the maximum date from the range input. */\n    _getMaxDate() {\n        return this._rangeInput.max;\n    }\n\n    /** Gets the date filter function from the range input. */\n    protected _getDateFilter() {\n        return this._rangeInput.dateFilter;\n    }\n\n    protected _outsideValueChanged = () => {\n        // Whenever the value changes outside the input we need to revalidate, because\n        // the validation state of each of the inputs depends on the other one.\n        this._validatorOnChange();\n    }\n\n    protected _parentDisabled() {\n        return this._rangeInput._groupDisabled;\n    }\n}\n\nconst _MatDateRangeInputBase:\n    CanUpdateErrorStateCtor & typeof MatDateRangeInputPartBase =\n    // Needs to be `as any`, because the base class is abstract.\n    mixinErrorState(MatDateRangeInputPartBase as any);\n\n/** Input for entering the start date in a `mat-date-range-input`. */\n@Directive({\n    selector: 'input[gipiMatStartDate]',\n    host: {\n        'class': 'mat-start-date mat-date-range-input-inner',\n        '[disabled]': 'disabled',\n        '(input)': '_onInput($event.target.value)',\n        '(change)': '_onChange()',\n        '(keydown)': '_onKeydown($event)',\n        '[attr.id]': '_rangeInput.id',\n        '[attr.aria-haspopup]': '_rangeInput.rangePicker ? \"dialog\" : null',\n        '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',\n        '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',\n        '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',\n        '(blur)': '_onBlur()',\n        'type': 'text',\n    },\n    providers: [\n        { provide: NG_VALUE_ACCESSOR, useExisting: MatStartDate, multi: true },\n        { provide: NG_VALIDATORS, useExisting: MatStartDate, multi: true }\n    ]\n})\nexport class MatStartDate<D> extends _MatDateRangeInputBase<D> implements CanUpdateErrorState, DoCheck, OnInit {\n\n    /** Validator that checks that the start date isn't after the end date. */\n    private _startValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const start = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        const end = this._model ? this._model.selection.end : null;\n        return (!start || !end || this._dateAdapter.compareDate(start, end) <= 0) ? null : { 'matStartDateInvalid': { 'end': end, 'actual': start } };\n    }\n\n    constructor(\n        @Inject(MAT_DATE_RANGE_INPUT_PARENT) rangeInput: MatDateRangeInputParent<D>,\n        elementRef: ElementRef<HTMLInputElement>,\n        defaultErrorStateMatcher: ErrorStateMatcher,\n        injector: Injector,\n        @Optional() parentForm: NgForm,\n        @Optional() parentFormGroup: FormGroupDirective,\n        @Optional() dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats\n    ) {\n\n        // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to\n        // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this\n        // constructor once ViewEngine is removed.\n        super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats);\n    }\n\n    ngOnInit() {\n        // Normally this happens automatically, but it seems to break if not added explicitly when all\n        // of the criteria below are met:\n        // 1) The class extends a TS mixin.\n        // 2) The application is running in ViewEngine.\n        // 3) The application is being transpiled through tsickle.\n        // This can be removed once google3 is completely migrated to Ivy.\n        super.ngOnInit();\n    }\n\n    ngDoCheck() {\n        // Normally this happens automatically, but it seems to break if not added explicitly when all\n        // of the criteria below are met:\n        // 1) The class extends a TS mixin.\n        // 2) The application is running in ViewEngine.\n        // 3) The application is being transpiled through tsickle.\n        // This can be removed once google3 is completely migrated to Ivy.\n        super.ngDoCheck();\n    }\n\n    protected _validator = Validators.compose([...super._getValidators(), this._startValidator]);\n\n    protected _getValueFromModel(modelValue: DateRange<D>) {\n        return modelValue.start;\n    }\n\n    protected _assignValueToModel(value: D | null) {\n        if (this._model) {\n            const range = new DateRange(value, this._model.selection.end);\n            this._model.updateSelection(range, this);\n            this._cvaOnChange(value);\n        }\n    }\n\n    protected _canEmitChangeEvent = (event: DateSelectionModelChange<DateRange<D>>): boolean => {\n        return event.source !== this._rangeInput._endInput;\n    }\n\n    protected _formatValue(value: D | null) {\n        super._formatValue(value);\n\n        // Any time the input value is reformatted we need to tell the parent.\n        this._rangeInput._handleChildValueChange();\n    }\n\n    /** Gets the value that should be used when mirroring the input's size. */\n    getMirrorValue(): string {\n        const element = this._elementRef.nativeElement;\n        const value = element.value;\n        return value.length > 0 ? value : element.placeholder;\n    }\n\n\n}\n\n\n/** Input for entering the end date in a `mat-date-range-input`. */\n@Directive({\n    selector: 'input[gipiMatEndDate]',\n    host: {\n        'class': 'mat-end-date mat-date-range-input-inner',\n        '[disabled]': 'disabled',\n        '(input)': '_onInput($event.target.value)',\n        '(change)': '_onChange()',\n        '(keydown)': '_onKeydown($event)',\n        '[attr.aria-haspopup]': '_rangeInput.rangePicker ? \"dialog\" : null',\n        '[attr.aria-owns]': '(_rangeInput.rangePicker?.opened && _rangeInput.rangePicker.id) || null',\n        '[attr.min]': '_getMinDate() ? _dateAdapter.toIso8601(_getMinDate()) : null',\n        '[attr.max]': '_getMaxDate() ? _dateAdapter.toIso8601(_getMaxDate()) : null',\n        '(blur)': '_onBlur()',\n        'type': 'text',\n    },\n    providers: [\n        { provide: NG_VALUE_ACCESSOR, useExisting: MatEndDate, multi: true },\n        { provide: NG_VALIDATORS, useExisting: MatEndDate, multi: true }\n    ]\n})\nexport class MatEndDate<D> extends _MatDateRangeInputBase<D> implements CanUpdateErrorState, DoCheck, OnInit {\n\n    /** Validator that checks that the end date isn't before the start date. */\n    private _endValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const end = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        const start = this._model ? this._model.selection.start : null;\n        return (!end || !start || this._dateAdapter.compareDate(end, start) >= 0) ? null : { 'matEndDateInvalid': { 'start': start, 'actual': end } };\n    }\n\n    constructor(\n        @Inject(MAT_DATE_RANGE_INPUT_PARENT) rangeInput: MatDateRangeInputParent<D>,\n        elementRef: ElementRef<HTMLInputElement>,\n        defaultErrorStateMatcher: ErrorStateMatcher,\n        injector: Injector,\n        @Optional() parentForm: NgForm,\n        @Optional() parentFormGroup: FormGroupDirective,\n        @Optional() dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats\n    ) {\n\n        // TODO(crisbeto): this constructor shouldn't be necessary, but ViewEngine doesn't seem to\n        // handle DI correctly when it is inherited from `MatDateRangeInputPartBase`. We can drop this\n        // constructor once ViewEngine is removed.\n        super(rangeInput, elementRef, defaultErrorStateMatcher, injector, parentForm, parentFormGroup, dateAdapter, dateFormats);\n    }\n\n    ngOnInit() {\n        // Normally this happens automatically, but it seems to break if not added explicitly when all\n        // of the criteria below are met:\n        // 1) The class extends a TS mixin.\n        // 2) The application is running in ViewEngine.\n        // 3) The application is being transpiled through tsickle.\n        // This can be removed once google3 is completely migrated to Ivy.\n        super.ngOnInit();\n    }\n\n    ngDoCheck() {\n        // Normally this happens automatically, but it seems to break if not added explicitly when all\n        // of the criteria below are met:\n        // 1) The class extends a TS mixin.\n        // 2) The application is running in ViewEngine.\n        // 3) The application is being transpiled through tsickle.\n        // This can be removed once google3 is completely migrated to Ivy.\n        super.ngDoCheck();\n    }\n\n    protected _validator = Validators.compose([...super._getValidators(), this._endValidator]);\n\n    protected _getValueFromModel(modelValue: DateRange<D>) {\n        return modelValue.end;\n    }\n\n    protected _assignValueToModel(value: D | null) {\n        if (this._model) {\n            const range = new DateRange(this._model.selection.start, value);\n            this._model.updateSelection(range, this);\n            this._cvaOnChange(value);\n        }\n    }\n\n    protected _canEmitChangeEvent = (event: DateSelectionModelChange<DateRange<D>>): boolean => {\n        return event.source !== this._rangeInput._startInput;\n    }\n\n    _onKeydown(event: KeyboardEvent) {\n        // If the user is pressing backspace on an empty end input, move focus back to the start.\n        if (event.keyCode === BACKSPACE && !this._elementRef.nativeElement.value) {\n            this._rangeInput._startInput.focus();\n        }\n\n        super._onKeydown(event);\n    }\n\n\n}\n"]}