@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm5/shared/gipi-components/datepicker/mat-datepicker/datepicker-base.js

@@ -0,0 +1,586 @@
+/**
+ * @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 } from "tslib";
+import { Directionality } from '@angular/cdk/bidi';
+import { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';
+import { Overlay, OverlayConfig, } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, Optional, Output, SimpleChanges, TemplateRef, ViewChild, ViewContainerRef, ViewEncapsulation } from '@angular/core';
+import { mixinColor, } from '@angular/material/core';
+import { MatDialog } from '@angular/material/dialog';
+import { merge, Subject, Subscription } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { MatCalendar } from './calendar';
+import { MAT_DATE_RANGE_SELECTION_STRATEGY, } from './date-range-selection-strategy';
+import { DateRange, ExtractDateTypeFromSelection, MatDateSelectionModel, } from './date-selection-model';
+import { matDatepickerAnimations } from './datepicker-animations';
+import { createMissingDateImplError } from './datepicker-errors';
+import { DateAdapter } from './shared/adapter/date-adapter';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Used to generate a unique ID for each datepicker instance. */
+var datepickerUid = 0;
+/** Injection token that determines the scroll handling while the calendar is open. */
+export var MAT_DATEPICKER_SCROLL_STRATEGY = new InjectionToken('mat-datepicker-scroll-strategy');
+/** @docs-private */
+export function MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay) {
+    return function () { return overlay.scrollStrategies.reposition(); };
+}
+/** @docs-private */
+export var MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+    provide: MAT_DATEPICKER_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY,
+};
+// Boilerplate for applying mixins to MatDatepickerContent.
+/** @docs-private */
+var MatDatepickerContentBase = /** @class */ (function () {
+    function MatDatepickerContentBase(_elementRef) {
+        this._elementRef = _elementRef;
+    }
+    return MatDatepickerContentBase;
+}());
+var _MatDatepickerContentMixinBase = mixinColor(MatDatepickerContentBase);
+/**
+ * Component used as the content for the datepicker dialog and popup. We use this instead of using
+ * MatCalendar directly as the content so we can control the initial focus. This also gives us a
+ * place to put additional features of the popup that are not part of the calendar itself in the
+ * future. (e.g. confirmation buttons).
+ * @docs-private
+ */
+var MatDatepickerContent = /** @class */ (function (_super) {
+    __extends(MatDatepickerContent, _super);
+    function MatDatepickerContent(elementRef, 
+    /**
+     * @deprecated `_changeDetectorRef`, `_model` and `_rangeSelectionStrategy`
+     * parameters to become required.
+     * @breaking-change 11.0.0
+     */
+    _changeDetectorRef, _model, _dateAdapter, _rangeSelectionStrategy) {
+        var _this = _super.call(this, elementRef) || this;
+        _this._changeDetectorRef = _changeDetectorRef;
+        _this._model = _model;
+        _this._dateAdapter = _dateAdapter;
+        _this._rangeSelectionStrategy = _rangeSelectionStrategy;
+        _this._subscriptions = new Subscription();
+        /** Current state of the animation. */
+        _this._animationState = 'enter';
+        /** Emits when an animation has finished. */
+        _this._animationDone = new Subject();
+        return _this;
+    }
+    MatDatepickerContent.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef.
+        if (this._changeDetectorRef) {
+            this._subscriptions.add(this.datepicker._stateChanges.subscribe(function () {
+                _this._changeDetectorRef.markForCheck();
+            }));
+        }
+        this._calendar.focusActiveCell();
+    };
+    MatDatepickerContent.prototype.ngOnDestroy = function () {
+        this._subscriptions.unsubscribe();
+        this._animationDone.complete();
+    };
+    MatDatepickerContent.prototype._handleUserSelection = function (event) {
+        // @breaking-change 11.0.0 Remove null checks for _model,
+        // _rangeSelectionStrategy and _dateAdapter.
+        if (this._model && this._dateAdapter) {
+            var selection = this._model.selection;
+            var value = event.value;
+            var isRange = selection instanceof DateRange;
+            // If we're selecting a range and we have a selection strategy, always pass the value through
+            // there. Otherwise don't assign null values to the model, unless we're selecting a range.
+            // A null value when picking a range means that the user cancelled the selection (e.g. by
+            // pressing escape), whereas when selecting a single value it means that the value didn't
+            // change. This isn't very intuitive, but it's here for backwards-compatibility.
+            if (isRange && this._rangeSelectionStrategy) {
+                var newSelection = this._rangeSelectionStrategy.selectionFinished(value, selection, event.event);
+                this._model.updateSelection(newSelection, this);
+            }
+            else if (value && (isRange ||
+                !this._dateAdapter.sameDate(value, selection))) {
+                this._model.add(value);
+            }
+        }
+        if (!this._model || this._model.isComplete()) {
+            this.datepicker.close();
+        }
+    };
+    MatDatepickerContent.prototype._startExitAnimation = function () {
+        this._animationState = 'void';
+        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef`.
+        if (this._changeDetectorRef) {
+            this._changeDetectorRef.markForCheck();
+        }
+    };
+    MatDatepickerContent.prototype._getSelected = function () {
+        // @breaking-change 11.0.0 Remove null check for `_model`.
+        return this._model ? this._model.selection : null;
+    };
+    MatDatepickerContent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: ChangeDetectorRef },
+        { type: MatDateSelectionModel },
+        { type: DateAdapter },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_RANGE_SELECTION_STRATEGY,] }] }
+    ]; };
+    __decorate([
+        ViewChild(MatCalendar, { static: true }),
+        __metadata("design:type", MatCalendar)
+    ], MatDatepickerContent.prototype, "_calendar", void 0);
+    MatDatepickerContent = __decorate([
+        Component({
+            selector: 'gipi-mat-datepicker-content',
+            template: "<gipi-mat-calendar cdkTrapFocus\n                   [id]=\"datepicker.id\"\n                   [ngClass]=\"datepicker.panelClass\"\n                   [startAt]=\"datepicker.startAt\"\n                   [startView]=\"datepicker.startView\"\n                   [minDate]=\"datepicker._getMinDate()\"\n                   [maxDate]=\"datepicker._getMaxDate()\"\n                   [dateFilter]=\"datepicker._getDateFilter()\"\n                   [templatePresetRange]=\"datepicker.templatePresetRange\"\n                   [selected]=\"_getSelected()\"\n                   [dateClass]=\"datepicker.dateClass\"\n                   [comparisonStart]=\"comparisonStart\"\n                   [comparisonEnd]=\"comparisonEnd\"\n                   [@fadeInCalendar]=\"'enter'\"\n                   (yearSelected)=\"datepicker._selectYear($event)\"\n                   (monthSelected)=\"datepicker._selectMonth($event)\"\n                   (_userSelection)=\"_handleUserSelection($event)\">\n</gipi-mat-calendar>",
+            host: {
+                'class': 'mat-datepicker-content',
+                '[@transformPanel]': '_animationState',
+                '(@transformPanel.done)': '_animationDone.next()',
+                '[class.mat-datepicker-content-touch]': 'datepicker.touchUi',
+            },
+            animations: [
+                matDatepickerAnimations.transformPanel,
+                matDatepickerAnimations.fadeInCalendar,
+            ],
+            exportAs: 'gipiMatDatepickerContent',
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            inputs: ['color'],
+            styles: [".mat-datepicker-content{display:block;border-radius:4px}.mat-datepicker-content .mat-calendar{min-width:296px;height:365px}.mat-datepicker-content .gipi-mat-calendar-wrapper .gipi-mat-calendar-content{min-width:296px;min-height:365px;border-left:1px solid rgba(0,0,0,.12)}.mat-datepicker-content-touch{display:block;max-height:80vh;overflow:auto;margin:-24px}.mat-datepicker-content-touch .mat-calendar{min-width:250px;min-height:312px;max-width:750px;max-height:788px}@media all and (orientation:landscape){.mat-datepicker-content-touch .mat-calendar{width:64vh;height:80vh}}@media all and (orientation:portrait){.mat-datepicker-content-touch .mat-calendar{width:80vw;height:100vw}}"]
+        }),
+        __param(4, Optional()), __param(4, Inject(MAT_DATE_RANGE_SELECTION_STRATEGY)),
+        __metadata("design:paramtypes", [ElementRef,
+            ChangeDetectorRef,
+            MatDateSelectionModel,
+            DateAdapter, Object])
+    ], MatDatepickerContent);
+    return MatDatepickerContent;
+}(_MatDatepickerContentMixinBase));
+export { MatDatepickerContent };
+/** Base class for a datepicker. */
+var MatDatepickerBase = /** @class */ (function () {
+    function MatDatepickerBase(_dialog, _overlay, _ngZone, _viewContainerRef, scrollStrategy, _dateAdapter, _dir, _document, _model) {
+        this._dialog = _dialog;
+        this._overlay = _overlay;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._dateAdapter = _dateAdapter;
+        this._dir = _dir;
+        this._document = _document;
+        this._model = _model;
+        this._inputStateChanges = Subscription.EMPTY;
+        /** The view that the calendar should start in. */
+        this.startView = 'month';
+        this._touchUi = false;
+        /** Preferred position of the datepicker in the X axis. */
+        this.xPosition = 'start';
+        /** Preferred position of the datepicker in the Y axis. */
+        this.yPosition = 'below';
+        /**
+         * Emits selected year in multiyear view.
+         * This doesn't imply a change on the selected date.
+         */
+        this.yearSelected = new EventEmitter();
+        /**
+         * Emits selected month in year view.
+         * This doesn't imply a change on the selected date.
+         */
+        this.monthSelected = new EventEmitter();
+        /** Emits when the datepicker has been opened. */
+        this.openedStream = new EventEmitter();
+        /** Emits when the datepicker has been closed. */
+        this.closedStream = new EventEmitter();
+        this._opened = false;
+        /** The id for the datepicker calendar. */
+        this.id = "mat-datepicker-" + datepickerUid++;
+        /** The element that was focused before the datepicker was opened. */
+        this._focusedElementBeforeOpen = null;
+        /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */
+        this._backdropHarnessClass = this.id + "-backdrop";
+        /** Emits when the datepicker's state changes. */
+        this._stateChanges = new Subject();
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        this._scrollStrategy = scrollStrategy;
+    }
+    Object.defineProperty(MatDatepickerBase.prototype, "startAt", {
+        /** The date to open the calendar to initially. */
+        get: function () {
+            // If an explicit startAt is set we start there, otherwise we start at whatever the currently
+            // selected value is.
+            return this._startAt || (this._datepickerInput ? this._datepickerInput.getStartValue() : null);
+        },
+        set: function (value) {
+            this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDatepickerBase.prototype, "color", {
+        /** Color palette to use on the datepicker's calendar. */
+        get: function () {
+            return this._color || (this._datepickerInput ? this._datepickerInput.getThemePalette() : undefined);
+        },
+        set: function (value) {
+            this._color = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDatepickerBase.prototype, "touchUi", {
+        /**
+         * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather
+         * than a popup and elements have more padding to allow for bigger touch targets.
+         */
+        get: function () { return this._touchUi; },
+        set: function (value) {
+            this._touchUi = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDatepickerBase.prototype, "disabled", {
+        /** Whether the datepicker pop-up should be disabled. */
+        get: function () {
+            return this._disabled === undefined && this._datepickerInput ?
+                this._datepickerInput.disabled : !!this._disabled;
+        },
+        set: function (value) {
+            var newValue = coerceBooleanProperty(value);
+            if (newValue !== this._disabled) {
+                this._disabled = newValue;
+                this._stateChanges.next(undefined);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDatepickerBase.prototype, "opened", {
+        /** Whether the calendar is open. */
+        get: function () { return this._opened; },
+        set: function (value) {
+            coerceBooleanProperty(value) ? this.open() : this.close();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** The minimum selectable date. */
+    MatDatepickerBase.prototype._getMinDate = function () {
+        return this._datepickerInput && this._datepickerInput.min;
+    };
+    /** The maximum selectable date. */
+    MatDatepickerBase.prototype._getMaxDate = function () {
+        return this._datepickerInput && this._datepickerInput.max;
+    };
+    MatDatepickerBase.prototype._getDateFilter = function () {
+        return this._datepickerInput && this._datepickerInput.dateFilter;
+    };
+    MatDatepickerBase.prototype.ngOnChanges = function (changes) {
+        var positionChange = changes['xPosition'] || changes['yPosition'];
+        if (positionChange && !positionChange.firstChange && this._popupRef) {
+            this._setConnectedPositions(this._popupRef.getConfig().positionStrategy);
+            if (this.opened) {
+                this._popupRef.updatePosition();
+            }
+        }
+        this._stateChanges.next(undefined);
+    };
+    MatDatepickerBase.prototype.ngOnDestroy = function () {
+        this._destroyPopup();
+        this.close();
+        this._inputStateChanges.unsubscribe();
+        this._stateChanges.complete();
+    };
+    /** Selects the given date */
+    MatDatepickerBase.prototype.select = function (date) {
+        this._model.add(date);
+    };
+    /** Emits the selected year in multiyear view */
+    MatDatepickerBase.prototype._selectYear = function (normalizedYear) {
+        this.yearSelected.emit(normalizedYear);
+    };
+    /** Emits selected month in year view */
+    MatDatepickerBase.prototype._selectMonth = function (normalizedMonth) {
+        this.monthSelected.emit(normalizedMonth);
+    };
+    /**
+     * Register an input with this datepicker.
+     * @param input The datepicker input to register with this datepicker.
+     * @returns Selection model that the input should hook itself up to.
+     */
+    MatDatepickerBase.prototype._registerInput = function (input) {
+        var _this = this;
+        if (this._datepickerInput) {
+            throw Error('A MatDatepicker can only be associated with a single input.');
+        }
+        this._inputStateChanges.unsubscribe();
+        this._datepickerInput = input;
+        this._inputStateChanges = input.stateChanges.subscribe(function () { return _this._stateChanges.next(undefined); });
+        return this._model;
+    };
+    /** Open the calendar. */
+    MatDatepickerBase.prototype.open = function () {
+        if (this._opened || this.disabled) {
+            return;
+        }
+        if (!this._datepickerInput) {
+            throw Error('Attempted to open an MatDatepicker with no associated input.');
+        }
+        if (this._document) {
+            this._focusedElementBeforeOpen = this._document.activeElement;
+        }
+        this.touchUi ? this._openAsDialog() : this._openAsPopup();
+        this._opened = true;
+        this.openedStream.emit();
+    };
+    /** Close the calendar. */
+    MatDatepickerBase.prototype.close = function () {
+        var _this = this;
+        if (!this._opened) {
+            return;
+        }
+        if (this._popupComponentRef && this._popupRef) {
+            var instance = this._popupComponentRef.instance;
+            instance._startExitAnimation();
+            instance._animationDone.pipe(take(1)).subscribe(function () { return _this._destroyPopup(); });
+        }
+        if (this._dialogRef) {
+            this._dialogRef.close();
+            this._dialogRef = null;
+        }
+        var completeClose = function () {
+            // The `_opened` could've been reset already if
+            // we got two events in quick succession.
+            if (_this._opened) {
+                _this._opened = false;
+                _this.closedStream.emit();
+                _this._focusedElementBeforeOpen = null;
+            }
+        };
+        if (this._focusedElementBeforeOpen &&
+            typeof this._focusedElementBeforeOpen.focus === 'function') {
+            // Because IE moves focus asynchronously, we can't count on it being restored before we've
+            // marked the datepicker as closed. If the event fires out of sequence and the element that
+            // we're refocusing opens the datepicker on focus, the user could be stuck with not being
+            // able to close the calendar at all. We work around it by making the logic, that marks
+            // the datepicker as closed, async as well.
+            this._focusedElementBeforeOpen.focus();
+            setTimeout(completeClose);
+        }
+        else {
+            completeClose();
+        }
+    };
+    /** Open the calendar as a dialog. */
+    MatDatepickerBase.prototype._openAsDialog = function () {
+        var _this = this;
+        // Usually this would be handled by `open` which ensures that we can only have one overlay
+        // open at a time, however since we reset the variables in async handlers some overlays
+        // may slip through if the user opens and closes multiple times in quick succession (e.g.
+        // by holding down the enter key).
+        if (this._dialogRef) {
+            this._dialogRef.close();
+        }
+        this._dialogRef = this._dialog.open(MatDatepickerContent, {
+            direction: this._dir ? this._dir.value : 'ltr',
+            viewContainerRef: this._viewContainerRef,
+            panelClass: 'mat-datepicker-dialog',
+            // These values are all the same as the defaults, but we set them explicitly so that the
+            // datepicker dialog behaves consistently even if the user changed the defaults.
+            hasBackdrop: true,
+            disableClose: false,
+            backdropClass: "cdk-overlay-dark-backdrop, " + this._backdropHarnessClass,
+            width: '',
+            height: '',
+            minWidth: '',
+            minHeight: '',
+            maxWidth: '80vw',
+            maxHeight: '',
+            position: {},
+            autoFocus: true,
+            // `MatDialog` has focus restoration built in, however we want to disable it since the
+            // datepicker also has focus restoration for dropdown mode. We want to do this, in order
+            // to ensure that the timing is consistent between dropdown and dialog modes since `MatDialog`
+            // restores focus when the animation is finished, but the datepicker does it immediately.
+            // Furthermore, this avoids any conflicts where the datepicker consumer might move focus
+            // inside the `closed` event which is dispatched immediately.
+            restoreFocus: false
+        });
+        this._dialogRef.afterClosed().subscribe(function () { return _this.close(); });
+        this._forwardContentValues(this._dialogRef.componentInstance);
+    };
+    /** Open the calendar as a popup. */
+    MatDatepickerBase.prototype._openAsPopup = function () {
+        var _this = this;
+        var portal = new ComponentPortal(MatDatepickerContent, this._viewContainerRef);
+        this._destroyPopup();
+        this._createPopup();
+        this._popupComponentRef = this._popupRef.attach(portal);
+        this._forwardContentValues(this._popupComponentRef.instance);
+        // Update the position once the calendar has rendered.
+        this._ngZone.onStable.pipe(take(1)).subscribe(function () {
+            _this._popupRef.updatePosition();
+        });
+    };
+    /** Forwards relevant values from the datepicker to the datepicker content inside the overlay. */
+    MatDatepickerBase.prototype._forwardContentValues = function (instance) {
+        instance.datepicker = this;
+        instance.color = this.color;
+    };
+    /** Create the popup. */
+    MatDatepickerBase.prototype._createPopup = function () {
+        var _this = this;
+        var positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())
+            .withTransformOriginOn('.mat-datepicker-content')
+            .withFlexibleDimensions(false)
+            .withViewportMargin(8)
+            .withLockedPosition();
+        var overlayConfig = new OverlayConfig({
+            positionStrategy: this._setConnectedPositions(positionStrategy),
+            hasBackdrop: true,
+            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],
+            direction: this._dir,
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: 'mat-datepicker-popup',
+        });
+        this._popupRef = this._overlay.create(overlayConfig);
+        this._popupRef.overlayElement.setAttribute('role', 'dialog');
+        merge(this._popupRef.backdropClick(), this._popupRef.detachments(), this._popupRef.keydownEvents().pipe(filter(function (event) {
+            // Closing on alt + up is only valid when there's an input associated with the datepicker.
+            return event.keyCode === ESCAPE || (_this._datepickerInput && event.altKey && event.keyCode === UP_ARROW);
+        }))).subscribe(function (event) {
+            if (event) {
+                event.preventDefault();
+            }
+            _this.close();
+        });
+    };
+    /** Destroys the current popup overlay. */
+    MatDatepickerBase.prototype._destroyPopup = function () {
+        if (this._popupRef) {
+            this._popupRef.dispose();
+            this._popupRef = this._popupComponentRef = null;
+        }
+    };
+    /** Sets the positions of the datepicker in dropdown mode based on the current configuration. */
+    MatDatepickerBase.prototype._setConnectedPositions = function (strategy) {
+        var primaryX = this.xPosition === 'end' ? 'end' : 'start';
+        var secondaryX = primaryX === 'start' ? 'end' : 'start';
+        var primaryY = this.yPosition === 'above' ? 'bottom' : 'top';
+        var secondaryY = primaryY === 'top' ? 'bottom' : 'top';
+        return strategy.withPositions([
+            {
+                originX: primaryX,
+                originY: secondaryY,
+                overlayX: primaryX,
+                overlayY: primaryY
+            },
+            {
+                originX: primaryX,
+                originY: primaryY,
+                overlayX: primaryX,
+                overlayY: secondaryY
+            },
+            {
+                originX: secondaryX,
+                originY: secondaryY,
+                overlayX: secondaryX,
+                overlayY: primaryY
+            },
+            {
+                originX: secondaryX,
+                originY: primaryY,
+                overlayX: secondaryX,
+                overlayY: secondaryY
+            }
+        ]);
+    };
+    __decorate([
+        Input(),
+        __metadata("design:type", TemplateRef)
+    ], MatDatepickerBase.prototype, "templatePresetRange", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatDatepickerBase.prototype, "startAt", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MatDatepickerBase.prototype, "startView", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], MatDatepickerBase.prototype, "color", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MatDatepickerBase.prototype, "touchUi", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MatDatepickerBase.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MatDatepickerBase.prototype, "xPosition", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MatDatepickerBase.prototype, "yPosition", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatDatepickerBase.prototype, "yearSelected", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatDatepickerBase.prototype, "monthSelected", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], MatDatepickerBase.prototype, "panelClass", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatDatepickerBase.prototype, "dateClass", void 0);
+    __decorate([
+        Output('opened'),
+        __metadata("design:type", EventEmitter)
+    ], MatDatepickerBase.prototype, "openedStream", void 0);
+    __decorate([
+        Output('closed'),
+        __metadata("design:type", EventEmitter)
+    ], MatDatepickerBase.prototype, "closedStream", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MatDatepickerBase.prototype, "opened", null);
+    MatDatepickerBase = __decorate([
+        __param(4, Inject(MAT_DATEPICKER_SCROLL_STRATEGY)),
+        __param(5, Optional()),
+        __param(6, Optional()),
+        __param(7, Optional()), __param(7, Inject(DOCUMENT)),
+        __metadata("design:paramtypes", [MatDialog,
+            Overlay,
+            NgZone,
+            ViewContainerRef, Object, DateAdapter,
+            Directionality, Object, MatDateSelectionModel])
+    ], MatDatepickerBase);
+    return MatDatepickerBase;
+}());
+export { MatDatepickerBase };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-base.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/datepicker-base.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAqC,OAAO,EAAE,aAAa,GAA+B,MAAM,sBAAsB,CAAC;AAC9H,OAAO,EAAE,eAAe,EAAiB,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACnT,OAAO,EAA0B,UAAU,GAAiB,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,SAAS,EAAgB,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,KAAK,EAAc,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAE,iCAAiC,GAAkC,MAAM,iCAAiC,CAAC;AACpH,OAAO,EAAE,SAAS,EAAE,4BAA4B,EAAE,qBAAqB,GAAG,MAAM,wBAAwB,CAAC;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,iEAAiE;AACjE,IAAI,aAAa,GAAG,CAAC,CAAC;AAEtB,sFAAsF;AACtF,MAAM,CAAC,IAAM,8BAA8B,GAAG,IAAI,cAAc,CAAuB,gCAAgC,CAAC,CAAC;AAEzH,oBAAoB;AACpB,MAAM,UAAU,sCAAsC,CAAC,OAAgB;IACnE,OAAO,cAAM,OAAA,OAAO,CAAC,gBAAgB,CAAC,UAAU,EAAE,EAArC,CAAqC,CAAC;AACvD,CAAC;AAQD,oBAAoB;AACpB,MAAM,CAAC,IAAM,+CAA+C,GAAG;IAC3D,OAAO,EAAE,8BAA8B;IACvC,IAAI,EAAE,CAAC,OAAO,CAAC;IACf,UAAU,EAAE,sCAAsC;CACrD,CAAC;AAEF,2DAA2D;AAC3D,oBAAoB;AACpB;IACI,kCAAmB,WAAuB;QAAvB,gBAAW,GAAX,WAAW,CAAY;IAAI,CAAC;IACnD,+BAAC;AAAD,CAAC,AAFD,IAEC;AAED,IAAM,8BAA8B,GAAmD,UAAU,CAAC,wBAAwB,CAAC,CAAC;AAE5H;;;;;;GAMG;AAoBH;IAAkF,wCAA8B;IAyB5G,8BACI,UAAsB;IACtB;;;;OAIG;IACK,kBAAsC,EACtC,MAAoC,EACpC,YAA6B,EAE7B,uBAA0D;QAXtE,YAaI,kBAAM,UAAU,CAAC,SACpB;QAPW,wBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,YAAM,GAAN,MAAM,CAA8B;QACpC,kBAAY,GAAZ,YAAY,CAAiB;QAE7B,6BAAuB,GAAvB,uBAAuB,CAAmC;QAlC9D,oBAAc,GAAG,IAAI,YAAY,EAAE,CAAC;QAiB5C,sCAAsC;QACtC,qBAAe,GAAqB,OAAO,CAAC;QAE5C,4CAA4C;QAC5C,oBAAc,GAAG,IAAI,OAAO,EAAQ,CAAC;;IAgBrC,CAAC;IAED,8CAAe,GAAf;QAAA,iBASC;QARG,qEAAqE;QACrE,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,SAAS,CAAC;gBAC5D,KAAI,CAAC,kBAAmB,CAAC,YAAY,EAAE,CAAC;YAC5C,CAAC,CAAC,CAAC,CAAC;SACP;QAED,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;IACrC,CAAC;IAED,0CAAW,GAAX;QACI,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC;QAClC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IAED,mDAAoB,GAApB,UAAqB,KAAqC;QACtD,yDAAyD;QACzD,4CAA4C;QAC5C,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,YAAY,EAAE;YAClC,IAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;YACxC,IAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;YAC1B,IAAM,OAAO,GAAG,SAAS,YAAY,SAAS,CAAC;YAE/C,6FAA6F;YAC7F,0FAA0F;YAC1F,yFAAyF;YACzF,yFAAyF;YACzF,gFAAgF;YAChF,IAAI,OAAO,IAAI,IAAI,CAAC,uBAAuB,EAAE;gBACzC,IAAM,YAAY,GAAG,IAAI,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,KAAK,EACrE,SAAoC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;gBACvD,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,YAA4B,EAAE,IAAI,CAAC,CAAC;aACnE;iBAAM,IAAI,KAAK,IAAI,CAAC,OAAO;gBACxB,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAyB,CAAC,CAAC,EAAE;gBAChE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;aAC1B;SACJ;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE;YAC1C,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;SAC3B;IACL,CAAC;IAED,kDAAmB,GAAnB;QACI,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;QAE9B,sEAAsE;QACtE,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;SAC1C;IACL,CAAC;IAED,2CAAY,GAAZ;QACI,0DAA0D;QAC1D,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,SAA+C,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5F,CAAC;;gBAvEe,UAAU;gBAMO,iBAAiB;gBAC7B,qBAAqB;gBACf,WAAW;gDACjC,QAAQ,YAAI,MAAM,SAAC,iCAAiC;;IA9Bf;QAAzC,SAAS,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;kCAAY,WAAW;2DAAI;IAL3D,oBAAoB;QAnBhC,SAAS,CAAC;YACP,QAAQ,EAAE,6BAA6B;YACvC,w/BAAsC;YAEtC,IAAI,EAAE;gBACF,OAAO,EAAE,wBAAwB;gBACjC,mBAAmB,EAAE,iBAAiB;gBACtC,wBAAwB,EAAE,uBAAuB;gBACjD,sCAAsC,EAAE,oBAAoB;aAC/D;YACD,UAAU,EAAE;gBACR,uBAAuB,CAAC,cAAc;gBACtC,uBAAuB,CAAC,cAAc;aACzC;YACD,QAAQ,EAAE,0BAA0B;YACpC,aAAa,EAAE,iBAAiB,CAAC,IAAI;YACrC,eAAe,EAAE,uBAAuB,CAAC,MAAM;YAC/C,MAAM,EAAE,CAAC,OAAO,CAAC;;SACpB,CAAC;QAoCO,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,iCAAiC,CAAC,CAAA;yCAT1C,UAAU;YAMO,iBAAiB;YAC7B,qBAAqB;YACf,WAAW;OAlC7B,oBAAoB,CAkGhC;IAAD,2BAAC;CAAA,AAlGD,CAAkF,8BAA8B,GAkG/G;SAlGY,oBAAoB;AAgHjC,mCAAmC;AACnC;IA0II,2BACY,OAAkB,EAClB,QAAiB,EACjB,OAAe,EACf,iBAAmC,EACH,cAAmB,EACvC,YAA4B,EAC5B,IAAoB,EACF,SAAc,EAC5C,MAAmC;QARnC,YAAO,GAAP,OAAO,CAAW;QAClB,aAAQ,GAAR,QAAQ,CAAS;QACjB,YAAO,GAAP,OAAO,CAAQ;QACf,sBAAiB,GAAjB,iBAAiB,CAAkB;QAEvB,iBAAY,GAAZ,YAAY,CAAgB;QAC5B,SAAI,GAAJ,IAAI,CAAgB;QACF,cAAS,GAAT,SAAS,CAAK;QAC5C,WAAM,GAAN,MAAM,CAA6B;QAhJvC,uBAAkB,GAAG,YAAY,CAAC,KAAK,CAAC;QAgBhD,kDAAkD;QACzC,cAAS,GAAoC,OAAO,CAAC;QAqBtD,aAAQ,GAAG,KAAK,CAAC;QAkBzB,0DAA0D;QAE1D,cAAS,GAAgC,OAAO,CAAC;QAEjD,0DAA0D;QAE1D,cAAS,GAAgC,OAAO,CAAC;QAEjD;;;WAGG;QACgB,iBAAY,GAAoB,IAAI,YAAY,EAAK,CAAC;QAEzE;;;WAGG;QACgB,kBAAa,GAAoB,IAAI,YAAY,EAAK,CAAC;QAQ1E,iDAAiD;QAC/B,iBAAY,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAE9E,iDAAiD;QAC/B,iBAAY,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAStE,YAAO,GAAG,KAAK,CAAC;QAExB,0CAA0C;QAC1C,OAAE,GAAW,oBAAkB,aAAa,EAAI,CAAC;QAyBjD,qEAAqE;QAC7D,8BAAyB,GAAuB,IAAI,CAAC;QAE7D,iGAAiG;QACzF,0BAAqB,GAAM,IAAI,CAAC,EAAE,cAAW,CAAC;QAKtD,iDAAiD;QACxC,kBAAa,GAAG,IAAI,OAAO,EAAQ,CAAC;QAazC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,MAAM,0BAA0B,CAAC,aAAa,CAAC,CAAC;SACnD;QAED,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;IAC1C,CAAC;IAjJD,sBAAI,sCAAO;QAFX,kDAAkD;aAElD;YACI,6FAA6F;YAC7F,qBAAqB;YACrB,OAAO,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACnG,CAAC;aACD,UAAY,KAAe;YACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QAC/F,CAAC;;;OAHA;IAWD,sBAAI,oCAAK;QAFT,yDAAyD;aAEzD;YACI,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACxG,CAAC;aACD,UAAU,KAAmB;YACzB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACxB,CAAC;;;OAHA;IAWD,sBAAI,sCAAO;QALX;;;WAGG;aAEH,cAAyB,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;aAChD,UAAY,KAAc;YACtB,IAAI,CAAC,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QACjD,CAAC;;;OAH+C;IAQhD,sBAAI,uCAAQ;QAFZ,wDAAwD;aAExD;YACI,OAAO,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAC1D,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;QAC1D,CAAC;aACD,UAAa,KAAc;YACvB,IAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;YAE9C,IAAI,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;gBAC7B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;gBAC1B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;aACtC;QACL,CAAC;;;OARA;IA8CD,sBAAI,qCAAM;QAFV,oCAAoC;aAEpC,cAAwB,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;aAC9C,UAAW,KAAc;YACrB,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QAC9D,CAAC;;;OAH6C;IAS9C,mCAAmC;IACnC,uCAAW,GAAX;QACI,OAAO,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC;IAC9D,CAAC;IAED,mCAAmC;IACnC,uCAAW,GAAX;QACI,OAAO,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC;IAC9D,CAAC;IAED,0CAAc,GAAd;QACI,OAAO,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC;IACrE,CAAC;IAyCD,uCAAW,GAAX,UAAY,OAAsB;QAC9B,IAAM,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QAEpE,IAAI,cAAc,IAAI,CAAC,cAAc,CAAC,WAAW,IAAI,IAAI,CAAC,SAAS,EAAE;YACjE,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,gBAAqD,CAAC,CAAC;YAE9G,IAAI,IAAI,CAAC,MAAM,EAAE;gBACb,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;aACnC;SACJ;QAED,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED,uCAAW,GAAX;QACI,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;QACtC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAED,6BAA6B;IAC7B,kCAAM,GAAN,UAAO,IAAO;QACV,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,gDAAgD;IAChD,uCAAW,GAAX,UAAY,cAAiB;QACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IAED,wCAAwC;IACxC,wCAAY,GAAZ,UAAa,eAAkB;QAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,0CAAc,GAAd,UAAe,KAAQ;QAAvB,iBAQC;QAPG,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACvB,MAAM,KAAK,CAAC,6DAA6D,CAAC,CAAC;SAC9E;QACD,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;QACtC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,EAAlC,CAAkC,CAAC,CAAC;QACjG,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,yBAAyB;IACzB,gCAAI,GAAJ;QACI,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC/B,OAAO;SACV;QACD,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACxB,MAAM,KAAK,CAAC,8DAA8D,CAAC,CAAC;SAC/E;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;SACjE;QAED,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QAC1D,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;IAED,0BAA0B;IAC1B,iCAAK,GAAL;QAAA,iBAoCC;QAnCG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACf,OAAO;SACV;QACD,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,SAAS,EAAE;YAC3C,IAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC;YAClD,QAAQ,CAAC,mBAAmB,EAAE,CAAC;YAC/B,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,aAAa,EAAE,EAApB,CAAoB,CAAC,CAAC;SAC/E;QACD,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SAC1B;QAED,IAAM,aAAa,GAAG;YAClB,+CAA+C;YAC/C,yCAAyC;YACzC,IAAI,KAAI,CAAC,OAAO,EAAE;gBACd,KAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,KAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;gBACzB,KAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;aACzC;QACL,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,yBAAyB;YAC9B,OAAO,IAAI,CAAC,yBAAyB,CAAC,KAAK,KAAK,UAAU,EAAE;YAC5D,0FAA0F;YAC1F,2FAA2F;YAC3F,yFAAyF;YACzF,uFAAuF;YACvF,2CAA2C;YAC3C,IAAI,CAAC,yBAAyB,CAAC,KAAK,EAAE,CAAC;YACvC,UAAU,CAAC,aAAa,CAAC,CAAC;SAC7B;aAAM;YACH,aAAa,EAAE,CAAC;SACnB;IACL,CAAC;IAED,qCAAqC;IAC7B,yCAAa,GAArB;QAAA,iBAuCC;QAtCG,0FAA0F;QAC1F,uFAAuF;QACvF,yFAAyF;QACzF,kCAAkC;QAClC,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;SAC3B;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAA6B,oBAAoB,EAAE;YAClF,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK;YAC9C,gBAAgB,EAAE,IAAI,CAAC,iBAAiB;YACxC,UAAU,EAAE,uBAAuB;YAEnC,wFAAwF;YACxF,gFAAgF;YAChF,WAAW,EAAE,IAAI;YACjB,YAAY,EAAE,KAAK;YACnB,aAAa,EAAE,gCAA8B,IAAI,CAAC,qBAAuB;YACzE,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,EAAE;YACZ,SAAS,EAAE,EAAE;YACb,QAAQ,EAAE,MAAM;YAChB,SAAS,EAAE,EAAE;YACb,QAAQ,EAAE,EAAE;YACZ,SAAS,EAAE,IAAI;YAEf,sFAAsF;YACtF,wFAAwF;YACxF,8FAA8F;YAC9F,yFAAyF;YACzF,wFAAwF;YACxF,6DAA6D;YAC7D,YAAY,EAAE,KAAK;SACtB,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,KAAK,EAAE,EAAZ,CAAY,CAAC,CAAC;QAC5D,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;IAClE,CAAC;IAED,oCAAoC;IAC5B,wCAAY,GAApB;QAAA,iBAYC;QAXG,IAAM,MAAM,GAAG,IAAI,eAAe,CAA6B,oBAAoB,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAE7G,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,SAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACzD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;QAE7D,sDAAsD;QACtD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1C,KAAI,CAAC,SAAU,CAAC,cAAc,EAAE,CAAC;QACrC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,iGAAiG;IACvF,iDAAqB,GAA/B,UAAgC,QAAoC;QAChE,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC;QAC3B,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IAChC,CAAC;IAED,wBAAwB;IAChB,wCAAY,GAApB;QAAA,iBAkCC;QAjCG,IAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;aAC5C,mBAAmB,CAAC,IAAI,CAAC,gBAAgB,CAAC,yBAAyB,EAAE,CAAC;aACtE,qBAAqB,CAAC,yBAAyB,CAAC;aAChD,sBAAsB,CAAC,KAAK,CAAC;aAC7B,kBAAkB,CAAC,CAAC,CAAC;aACrB,kBAAkB,EAAE,CAAC;QAE1B,IAAM,aAAa,GAAG,IAAI,aAAa,CAAC;YACpC,gBAAgB,EAAE,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,CAAC;YAC/D,WAAW,EAAE,IAAI;YACjB,aAAa,EAAE,CAAC,kCAAkC,EAAE,IAAI,CAAC,qBAAqB,CAAC;YAC/E,SAAS,EAAE,IAAI,CAAC,IAAI;YACpB,cAAc,EAAE,IAAI,CAAC,eAAe,EAAE;YACtC,UAAU,EAAE,sBAAsB;SACrC,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAE7D,KAAK,CACD,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAC9B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,EAC5B,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,UAAA,KAAK;YAC5C,0FAA0F;YAC1F,OAAO,KAAK,CAAC,OAAO,KAAK,MAAM,IAAI,CAAC,KAAI,CAAC,gBAAgB,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC;QAC7G,CAAC,CAAC,CAAC,CACN,CAAC,SAAS,CAAC,UAAA,KAAK;YACb,IAAI,KAAK,EAAE;gBACP,KAAK,CAAC,cAAc,EAAE,CAAC;aAC1B;YAED,KAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,0CAA0C;IAClC,yCAAa,GAArB;QACI,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;SACnD;IACL,CAAC;IAED,gGAAgG;IACxF,kDAAsB,GAA9B,UAA+B,QAA2C;QACtE,IAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;QAC5D,IAAM,UAAU,GAAG,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;QAC1D,IAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;QAC/D,IAAM,UAAU,GAAG,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;QAEzD,OAAO,QAAQ,CAAC,aAAa,CAAC;YAC1B;gBACI,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,UAAU;gBACnB,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,QAAQ;aACrB;YACD;gBACI,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,UAAU;aACvB;YACD;gBACI,OAAO,EAAE,UAAU;gBACnB,OAAO,EAAE,UAAU;gBACnB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,QAAQ;aACrB;YACD;gBACI,OAAO,EAAE,UAAU;gBACnB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;aACvB;SACJ,CAAC,CAAC;IACP,CAAC;IA/YQ;QAAR,KAAK,EAAE;kCAAsB,WAAW;kEAAM;IAI/C;QADC,KAAK,EAAE;;;oDAKP;IAOQ;QAAR,KAAK,EAAE;;wDAAsD;IAI9D;QADC,KAAK,EAAE;;;kDAGP;IAWD;QADC,KAAK,EAAE;;;oDACwC;IAQhD;QADC,KAAK,EAAE;;;qDAIP;IAaD;QADC,KAAK,EAAE;;wDACyC;IAIjD;QADC,KAAK,EAAE;;wDACyC;IAMvC;QAAT,MAAM,EAAE;kCAAwB,YAAY;2DAA4B;IAM/D;QAAT,MAAM,EAAE;kCAAyB,YAAY;4DAA4B;IAGjE;QAAR,KAAK,EAAE;;yDAA+B;IAG9B;QAAR,KAAK,EAAE;;wDAA4C;IAGlC;QAAjB,MAAM,CAAC,QAAQ,CAAC;kCAAe,YAAY;2DAAkC;IAG5D;QAAjB,MAAM,CAAC,QAAQ,CAAC;kCAAe,YAAY;2DAAkC;IAK9E;QADC,KAAK,EAAE;;;mDACsC;IA9F5B,iBAAiB;QA+I9B,WAAA,MAAM,CAAC,8BAA8B,CAAC,CAAA;QACtC,WAAA,QAAQ,EAAE,CAAA;QACV,WAAA,QAAQ,EAAE,CAAA;QACV,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,QAAQ,CAAC,CAAA;yCAPZ,SAAS;YACR,OAAO;YACR,MAAM;YACI,gBAAgB,UAET,WAAW;YACnB,cAAc,UAExB,qBAAqB;OAnJvB,iBAAiB,CAsZtC;IAAD,wBAAC;CAAA,AAtZD,IAsZC;SAtZqB,iBAAiB","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 { Directionality } from '@angular/cdk/bidi';\nimport { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';\nimport { FlexibleConnectedPositionStrategy, Overlay, OverlayConfig, OverlayRef, ScrollStrategy, } from '@angular/cdk/overlay';\nimport { ComponentPortal, ComponentType } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, Optional, Output, SimpleChanges, TemplateRef, ViewChild, ViewContainerRef, ViewEncapsulation } from '@angular/core';\nimport { CanColor, CanColorCtor, mixinColor, ThemePalette, } from '@angular/material/core';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { merge, Observable, Subject, Subscription } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { MatCalendar } from './calendar';\nimport { MatCalendarCellClassFunction, MatCalendarUserEvent } from './calendar-body';\nimport { MAT_DATE_RANGE_SELECTION_STRATEGY, MatDateRangeSelectionStrategy, } from './date-range-selection-strategy';\nimport { DateRange, ExtractDateTypeFromSelection, MatDateSelectionModel, } from './date-selection-model';\nimport { matDatepickerAnimations } from './datepicker-animations';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { DateFilterFn } from './datepicker-input-base';\nimport { DateAdapter } from './shared/adapter/date-adapter';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\n/** Used to generate a unique ID for each datepicker instance. */\nlet datepickerUid = 0;\n\n/** Injection token that determines the scroll handling while the calendar is open. */\nexport const MAT_DATEPICKER_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>('mat-datepicker-scroll-strategy');\n\n/** @docs-private */\nexport function MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n    return () => overlay.scrollStrategies.reposition();\n}\n\n/** Possible positions for the datepicker dropdown along the X axis. */\nexport type DatepickerDropdownPositionX = 'start' | 'end';\n\n/** Possible positions for the datepicker dropdown along the Y axis. */\nexport type DatepickerDropdownPositionY = 'above' | 'below';\n\n/** @docs-private */\nexport const MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_DATEPICKER_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY,\n};\n\n// Boilerplate for applying mixins to MatDatepickerContent.\n/** @docs-private */\nclass MatDatepickerContentBase {\n    constructor(public _elementRef: ElementRef) { }\n}\n\nconst _MatDatepickerContentMixinBase: CanColorCtor & typeof MatDatepickerContentBase = mixinColor(MatDatepickerContentBase);\n\n/**\n * Component used as the content for the datepicker dialog and popup. We use this instead of using\n * MatCalendar directly as the content so we can control the initial focus. This also gives us a\n * place to put additional features of the popup that are not part of the calendar itself in the\n * future. (e.g. confirmation buttons).\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-datepicker-content',\n    templateUrl: 'datepicker-content.html',\n    styleUrls: ['datepicker-content.scss'],\n    host: {\n        'class': 'mat-datepicker-content',\n        '[@transformPanel]': '_animationState',\n        '(@transformPanel.done)': '_animationDone.next()',\n        '[class.mat-datepicker-content-touch]': 'datepicker.touchUi',\n    },\n    animations: [\n        matDatepickerAnimations.transformPanel,\n        matDatepickerAnimations.fadeInCalendar,\n    ],\n    exportAs: 'gipiMatDatepickerContent',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    inputs: ['color'],\n})\nexport class MatDatepickerContent<S, D = ExtractDateTypeFromSelection<S>> extends _MatDatepickerContentMixinBase implements AfterViewInit, OnDestroy, CanColor {\n\n    private _subscriptions = new Subscription();\n\n    /** Reference to the internal calendar component. */\n    @ViewChild(MatCalendar, { static: true }) _calendar: MatCalendar<D>;\n\n    /** Reference to the datepicker that created the overlay. */\n    datepicker: MatDatepickerBase<any, S, D>;\n\n    /** Start of the comparison range. */\n    comparisonStart: D | null;\n\n    /** End of the comparison range. */\n    comparisonEnd: D | null;\n\n    /** Whether the datepicker is above or below the input. */\n    _isAbove: boolean;\n\n    /** Current state of the animation. */\n    _animationState: 'enter' | 'void' = 'enter';\n\n    /** Emits when an animation has finished. */\n    _animationDone = new Subject<void>();\n\n    constructor(\n        elementRef: ElementRef,\n        /**\n         * @deprecated `_changeDetectorRef`, `_model` and `_rangeSelectionStrategy`\n         * parameters to become required.\n         * @breaking-change 11.0.0\n         */\n        private _changeDetectorRef?: ChangeDetectorRef,\n        private _model?: MatDateSelectionModel<S, D>,\n        private _dateAdapter?: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_RANGE_SELECTION_STRATEGY)\n        private _rangeSelectionStrategy?: MatDateRangeSelectionStrategy<D>\n    ) {\n        super(elementRef);\n    }\n\n    ngAfterViewInit() {\n        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef.\n        if (this._changeDetectorRef) {\n            this._subscriptions.add(this.datepicker._stateChanges.subscribe(() => {\n                this._changeDetectorRef!.markForCheck();\n            }));\n        }\n\n        this._calendar.focusActiveCell();\n    }\n\n    ngOnDestroy() {\n        this._subscriptions.unsubscribe();\n        this._animationDone.complete();\n    }\n\n    _handleUserSelection(event: MatCalendarUserEvent<D | null>) {\n        // @breaking-change 11.0.0 Remove null checks for _model,\n        // _rangeSelectionStrategy and _dateAdapter.\n        if (this._model && this._dateAdapter) {\n            const selection = this._model.selection;\n            const value = event.value;\n            const isRange = selection instanceof DateRange;\n\n            // If we're selecting a range and we have a selection strategy, always pass the value through\n            // there. Otherwise don't assign null values to the model, unless we're selecting a range.\n            // A null value when picking a range means that the user cancelled the selection (e.g. by\n            // pressing escape), whereas when selecting a single value it means that the value didn't\n            // change. This isn't very intuitive, but it's here for backwards-compatibility.\n            if (isRange && this._rangeSelectionStrategy) {\n                const newSelection = this._rangeSelectionStrategy.selectionFinished(value,\n                    selection as unknown as DateRange<D>, event.event);\n                this._model.updateSelection(newSelection as unknown as S, this);\n            } else if (value && (isRange ||\n                !this._dateAdapter.sameDate(value, selection as unknown as D))) {\n                this._model.add(value);\n            }\n        }\n\n        if (!this._model || this._model.isComplete()) {\n            this.datepicker.close();\n        }\n    }\n\n    _startExitAnimation() {\n        this._animationState = 'void';\n\n        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef`.\n        if (this._changeDetectorRef) {\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n\n    _getSelected() {\n        // @breaking-change 11.0.0 Remove null check for `_model`.\n        return this._model ? this._model.selection as unknown as D | DateRange<D> | null : null;\n    }\n}\n\n/** Form control that can be associated with a datepicker. */\nexport interface MatDatepickerControl<D> {\n    getStartValue(): D | null;\n    getThemePalette(): ThemePalette;\n    min: D | null;\n    max: D | null;\n    disabled: boolean;\n    dateFilter: DateFilterFn<D>;\n    getConnectedOverlayOrigin(): ElementRef;\n    stateChanges: Observable<void>;\n}\n\n/** Base class for a datepicker. */\nexport abstract class MatDatepickerBase<C extends MatDatepickerControl<D>, S, D = any> implements OnDestroy, OnChanges {\n\n    private _scrollStrategy: () => ScrollStrategy;\n    private _inputStateChanges = Subscription.EMPTY;\n\n    @Input() templatePresetRange: TemplateRef<any>;\n\n    /** The date to open the calendar to initially. */\n    @Input()\n    get startAt(): D | null {\n        // If an explicit startAt is set we start there, otherwise we start at whatever the currently\n        // selected value is.\n        return this._startAt || (this._datepickerInput ? this._datepickerInput.getStartValue() : null);\n    }\n    set startAt(value: D | null) {\n        this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    private _startAt: D | null;\n\n    /** The view that the calendar should start in. */\n    @Input() startView: 'month' | 'year' | 'multi-year' = 'month';\n\n    /** Color palette to use on the datepicker's calendar. */\n    @Input()\n    get color(): ThemePalette {\n        return this._color || (this._datepickerInput ? this._datepickerInput.getThemePalette() : undefined);\n    }\n    set color(value: ThemePalette) {\n        this._color = value;\n    }\n    _color: ThemePalette;\n\n    /**\n     * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather\n     * than a popup and elements have more padding to allow for bigger touch targets.\n     */\n    @Input()\n    get touchUi(): boolean { return this._touchUi; }\n    set touchUi(value: boolean) {\n        this._touchUi = coerceBooleanProperty(value);\n    }\n    private _touchUi = false;\n\n    /** Whether the datepicker pop-up should be disabled. */\n    @Input()\n    get disabled(): boolean {\n        return this._disabled === undefined && this._datepickerInput ?\n            this._datepickerInput.disabled : !!this._disabled;\n    }\n    set disabled(value: boolean) {\n        const newValue = coerceBooleanProperty(value);\n\n        if (newValue !== this._disabled) {\n            this._disabled = newValue;\n            this._stateChanges.next(undefined);\n        }\n    }\n    private _disabled: boolean;\n\n    /** Preferred position of the datepicker in the X axis. */\n    @Input()\n    xPosition: DatepickerDropdownPositionX = 'start';\n\n    /** Preferred position of the datepicker in the Y axis. */\n    @Input()\n    yPosition: DatepickerDropdownPositionY = 'below';\n\n    /**\n     * Emits selected year in multiyear view.\n     * This doesn't imply a change on the selected date.\n     */\n    @Output() readonly yearSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /**\n     * Emits selected month in year view.\n     * This doesn't imply a change on the selected date.\n     */\n    @Output() readonly monthSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Classes to be passed to the date picker panel. Supports the same syntax as `ngClass`. */\n    @Input() panelClass: string | string[];\n\n    /** Function that can be used to add custom CSS classes to dates. */\n    @Input() dateClass: MatCalendarCellClassFunction<D>;\n\n    /** Emits when the datepicker has been opened. */\n    @Output('opened') openedStream: EventEmitter<void> = new EventEmitter<void>();\n\n    /** Emits when the datepicker has been closed. */\n    @Output('closed') closedStream: EventEmitter<void> = new EventEmitter<void>();\n\n\n    /** Whether the calendar is open. */\n    @Input()\n    get opened(): boolean { return this._opened; }\n    set opened(value: boolean) {\n        coerceBooleanProperty(value) ? this.open() : this.close();\n    }\n    private _opened = false;\n\n    /** The id for the datepicker calendar. */\n    id: string = `mat-datepicker-${datepickerUid++}`;\n\n    /** The minimum selectable date. */\n    _getMinDate(): D | null {\n        return this._datepickerInput && this._datepickerInput.min;\n    }\n\n    /** The maximum selectable date. */\n    _getMaxDate(): D | null {\n        return this._datepickerInput && this._datepickerInput.max;\n    }\n\n    _getDateFilter(): DateFilterFn<D> {\n        return this._datepickerInput && this._datepickerInput.dateFilter;\n    }\n\n    /** A reference to the overlay when the calendar is opened as a popup. */\n    private _popupRef: OverlayRef | null;\n\n    /** A reference to the dialog when the calendar is opened as a dialog. */\n    private _dialogRef: MatDialogRef<MatDatepickerContent<S, D>> | null;\n\n    /** Reference to the component instantiated in popup mode. */\n    private _popupComponentRef: ComponentRef<MatDatepickerContent<S, D>> | null;\n\n    /** The element that was focused before the datepicker was opened. */\n    private _focusedElementBeforeOpen: HTMLElement | null = null;\n\n    /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */\n    private _backdropHarnessClass = `${this.id}-backdrop`;\n\n    /** The input element this datepicker is associated with. */\n    _datepickerInput: C;\n\n    /** Emits when the datepicker's state changes. */\n    readonly _stateChanges = new Subject<void>();\n\n    constructor(\n        private _dialog: MatDialog,\n        private _overlay: Overlay,\n        private _ngZone: NgZone,\n        private _viewContainerRef: ViewContainerRef,\n        @Inject(MAT_DATEPICKER_SCROLL_STRATEGY) scrollStrategy: any,\n        @Optional() private _dateAdapter: DateAdapter<D>,\n        @Optional() private _dir: Directionality,\n        @Optional() @Inject(DOCUMENT) private _document: any,\n        private _model: MatDateSelectionModel<S, D>\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n\n        this._scrollStrategy = scrollStrategy;\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const positionChange = changes['xPosition'] || changes['yPosition'];\n\n        if (positionChange && !positionChange.firstChange && this._popupRef) {\n            this._setConnectedPositions(this._popupRef.getConfig().positionStrategy as FlexibleConnectedPositionStrategy);\n\n            if (this.opened) {\n                this._popupRef.updatePosition();\n            }\n        }\n\n        this._stateChanges.next(undefined);\n    }\n\n    ngOnDestroy() {\n        this._destroyPopup();\n        this.close();\n        this._inputStateChanges.unsubscribe();\n        this._stateChanges.complete();\n    }\n\n    /** Selects the given date */\n    select(date: D): void {\n        this._model.add(date);\n    }\n\n    /** Emits the selected year in multiyear view */\n    _selectYear(normalizedYear: D): void {\n        this.yearSelected.emit(normalizedYear);\n    }\n\n    /** Emits selected month in year view */\n    _selectMonth(normalizedMonth: D): void {\n        this.monthSelected.emit(normalizedMonth);\n    }\n\n    /**\n     * Register an input with this datepicker.\n     * @param input The datepicker input to register with this datepicker.\n     * @returns Selection model that the input should hook itself up to.\n     */\n    _registerInput(input: C): MatDateSelectionModel<S, D> {\n        if (this._datepickerInput) {\n            throw Error('A MatDatepicker can only be associated with a single input.');\n        }\n        this._inputStateChanges.unsubscribe();\n        this._datepickerInput = input;\n        this._inputStateChanges = input.stateChanges.subscribe(() => this._stateChanges.next(undefined));\n        return this._model;\n    }\n\n    /** Open the calendar. */\n    open(): void {\n        if (this._opened || this.disabled) {\n            return;\n        }\n        if (!this._datepickerInput) {\n            throw Error('Attempted to open an MatDatepicker with no associated input.');\n        }\n        if (this._document) {\n            this._focusedElementBeforeOpen = this._document.activeElement;\n        }\n\n        this.touchUi ? this._openAsDialog() : this._openAsPopup();\n        this._opened = true;\n        this.openedStream.emit();\n    }\n\n    /** Close the calendar. */\n    close(): void {\n        if (!this._opened) {\n            return;\n        }\n        if (this._popupComponentRef && this._popupRef) {\n            const instance = this._popupComponentRef.instance;\n            instance._startExitAnimation();\n            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyPopup());\n        }\n        if (this._dialogRef) {\n            this._dialogRef.close();\n            this._dialogRef = null;\n        }\n\n        const completeClose = () => {\n            // The `_opened` could've been reset already if\n            // we got two events in quick succession.\n            if (this._opened) {\n                this._opened = false;\n                this.closedStream.emit();\n                this._focusedElementBeforeOpen = null;\n            }\n        };\n\n        if (this._focusedElementBeforeOpen &&\n            typeof this._focusedElementBeforeOpen.focus === 'function') {\n            // Because IE moves focus asynchronously, we can't count on it being restored before we've\n            // marked the datepicker as closed. If the event fires out of sequence and the element that\n            // we're refocusing opens the datepicker on focus, the user could be stuck with not being\n            // able to close the calendar at all. We work around it by making the logic, that marks\n            // the datepicker as closed, async as well.\n            this._focusedElementBeforeOpen.focus();\n            setTimeout(completeClose);\n        } else {\n            completeClose();\n        }\n    }\n\n    /** Open the calendar as a dialog. */\n    private _openAsDialog(): void {\n        // Usually this would be handled by `open` which ensures that we can only have one overlay\n        // open at a time, however since we reset the variables in async handlers some overlays\n        // may slip through if the user opens and closes multiple times in quick succession (e.g.\n        // by holding down the enter key).\n        if (this._dialogRef) {\n            this._dialogRef.close();\n        }\n\n        this._dialogRef = this._dialog.open<MatDatepickerContent<S, D>>(MatDatepickerContent, {\n            direction: this._dir ? this._dir.value : 'ltr',\n            viewContainerRef: this._viewContainerRef,\n            panelClass: 'mat-datepicker-dialog',\n\n            // These values are all the same as the defaults, but we set them explicitly so that the\n            // datepicker dialog behaves consistently even if the user changed the defaults.\n            hasBackdrop: true,\n            disableClose: false,\n            backdropClass: `cdk-overlay-dark-backdrop, ${this._backdropHarnessClass}`,\n            width: '',\n            height: '',\n            minWidth: '',\n            minHeight: '',\n            maxWidth: '80vw',\n            maxHeight: '',\n            position: {},\n            autoFocus: true,\n\n            // `MatDialog` has focus restoration built in, however we want to disable it since the\n            // datepicker also has focus restoration for dropdown mode. We want to do this, in order\n            // to ensure that the timing is consistent between dropdown and dialog modes since `MatDialog`\n            // restores focus when the animation is finished, but the datepicker does it immediately.\n            // Furthermore, this avoids any conflicts where the datepicker consumer might move focus\n            // inside the `closed` event which is dispatched immediately.\n            restoreFocus: false\n        });\n\n        this._dialogRef.afterClosed().subscribe(() => this.close());\n        this._forwardContentValues(this._dialogRef.componentInstance);\n    }\n\n    /** Open the calendar as a popup. */\n    private _openAsPopup(): void {\n        const portal = new ComponentPortal<MatDatepickerContent<S, D>>(MatDatepickerContent, this._viewContainerRef);\n\n        this._destroyPopup();\n        this._createPopup();\n        this._popupComponentRef = this._popupRef!.attach(portal);\n        this._forwardContentValues(this._popupComponentRef.instance);\n\n        // Update the position once the calendar has rendered.\n        this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n            this._popupRef!.updatePosition();\n        });\n    }\n\n    /** Forwards relevant values from the datepicker to the datepicker content inside the overlay. */\n    protected _forwardContentValues(instance: MatDatepickerContent<S, D>) {\n        instance.datepicker = this;\n        instance.color = this.color;\n    }\n\n    /** Create the popup. */\n    private _createPopup(): void {\n        const positionStrategy = this._overlay.position()\n            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())\n            .withTransformOriginOn('.mat-datepicker-content')\n            .withFlexibleDimensions(false)\n            .withViewportMargin(8)\n            .withLockedPosition();\n\n        const overlayConfig = new OverlayConfig({\n            positionStrategy: this._setConnectedPositions(positionStrategy),\n            hasBackdrop: true,\n            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],\n            direction: this._dir,\n            scrollStrategy: this._scrollStrategy(),\n            panelClass: 'mat-datepicker-popup',\n        });\n\n        this._popupRef = this._overlay.create(overlayConfig);\n        this._popupRef.overlayElement.setAttribute('role', 'dialog');\n\n        merge(\n            this._popupRef.backdropClick(),\n            this._popupRef.detachments(),\n            this._popupRef.keydownEvents().pipe(filter(event => {\n                // Closing on alt + up is only valid when there's an input associated with the datepicker.\n                return event.keyCode === ESCAPE || (this._datepickerInput && event.altKey && event.keyCode === UP_ARROW);\n            }))\n        ).subscribe(event => {\n            if (event) {\n                event.preventDefault();\n            }\n\n            this.close();\n        });\n    }\n\n    /** Destroys the current popup overlay. */\n    private _destroyPopup() {\n        if (this._popupRef) {\n            this._popupRef.dispose();\n            this._popupRef = this._popupComponentRef = null;\n        }\n    }\n\n    /** Sets the positions of the datepicker in dropdown mode based on the current configuration. */\n    private _setConnectedPositions(strategy: FlexibleConnectedPositionStrategy) {\n        const primaryX = this.xPosition === 'end' ? 'end' : 'start';\n        const secondaryX = primaryX === 'start' ? 'end' : 'start';\n        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';\n        const secondaryY = primaryY === 'top' ? 'bottom' : 'top';\n\n        return strategy.withPositions([\n            {\n                originX: primaryX,\n                originY: secondaryY,\n                overlayX: primaryX,\n                overlayY: primaryY\n            },\n            {\n                originX: primaryX,\n                originY: primaryY,\n                overlayX: primaryX,\n                overlayY: secondaryY\n            },\n            {\n                originX: secondaryX,\n                originY: secondaryY,\n                overlayX: secondaryX,\n                overlayY: primaryY\n            },\n            {\n                originX: secondaryX,\n                originY: primaryY,\n                overlayX: secondaryX,\n                overlayY: secondaryY\n            }\n        ]);\n    }\n\n}\n"]}