@gipisistemas/ng-core 1.1.11 → 1.1.13

package/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/calendar.js

@@ -0,0 +1,676 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, UP_ARROW, } from '@angular/cdk/keycodes';
+import { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Inject, Input, NgZone, OnDestroy, Optional, Output, ViewEncapsulation, } from '@angular/core';
+import { MatDatepickerIntl } from '@angular/material/datepicker';
+import { first } from 'rxjs/operators';
+import { slideCalendar } from './datetimepicker-animations';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';
+import { getActiveOffset, isSameMultiYearView, yearsPerPage, yearsPerRow, } from './multi-year-view';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+import { GIPI_DATETIME_FORMATS, } from './shared/adapter/datetime-formats';
+/**
+ * A calendar that is used as part of the datepicker.
+ * @docs-private
+ */
+let GIPIDatetimepickerCalendarComponent = class GIPIDatetimepickerCalendarComponent {
+    constructor(_elementRef, _intl, _ngZone, _adapter, _dateFormats, changeDetectorRef) {
+        this._elementRef = _elementRef;
+        this._intl = _intl;
+        this._ngZone = _ngZone;
+        this._adapter = _adapter;
+        this._dateFormats = _dateFormats;
+        this._clockView = 'hour';
+        /** Active multi year view when click on year. */
+        this.multiYearSelector = true;
+        /** Whether the calendar should be started in month or year view. */
+        this.startView = 'month';
+        this.twelvehour = false;
+        this.timeInterval = 1;
+        this.ariaLabel = 'Use arrow keys to navigate';
+        this.ariaNextMonthLabel = 'Next month';
+        this.ariaPrevMonthLabel = 'Previous month';
+        this.ariaNextYearLabel = 'Next year';
+        this.ariaPrevYearLabel = 'Previous year';
+        this.ariaNextMultiYearLabel = 'Next year range';
+        this.ariaPrevMultiYearLabel = 'Previous year range';
+        /** Prevent user to select same date time */
+        this.preventSameDateTimeSelection = false;
+        this._type = 'date';
+        /** Emits when the currently selected date changes. */
+        this.selectedChange = new EventEmitter();
+        /** Emits when the view has been changed. **/
+        this.viewChanged = new EventEmitter();
+        this._userSelection = new EventEmitter();
+        /** Date filter for the month and year views. */
+        this._dateFilterForViews = (date) => {
+            return (!!date &&
+                (!this.dateFilter || this.dateFilter(date, GIPIDatetimepickerFilterType.DATE)) &&
+                (!this.minDate || this._adapter.compareDate(date, this.minDate) >= 0) &&
+                (!this.maxDate || this._adapter.compareDate(date, this.maxDate) <= 0));
+        };
+        if (!this._adapter) {
+            throw createMissingDateImplError('GIPIDatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');
+        }
+        this._intlChanges = _intl.changes.subscribe(() => changeDetectorRef.markForCheck());
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value || 'date';
+        if (this.type === 'year') {
+            this.multiYearSelector = true;
+        }
+    }
+    get startAt() {
+        return this._startAt;
+    }
+    set startAt(value) {
+        this._startAt = this._adapter.getValidDateOrNull(value);
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = this._adapter.getValidDateOrNull(value);
+    }
+    get minDate() {
+        return this._minDate;
+    }
+    set minDate(value) {
+        this._minDate = this._adapter.getValidDateOrNull(value);
+    }
+    get maxDate() {
+        return this._maxDate;
+    }
+    set maxDate(value) {
+        this._maxDate = this._adapter.getValidDateOrNull(value);
+    }
+    /** The current active date. This determines which time period is shown and which date is highlighted when using keyboard navigation. */
+    get _activeDate() {
+        return this._clampedActiveDate;
+    }
+    set _activeDate(value) {
+        const oldActiveDate = this._clampedActiveDate;
+        this._clampedActiveDate = this._adapter.clampDate(value, this.minDate, this.maxDate);
+        if (oldActiveDate &&
+            this._clampedActiveDate &&
+            this.currentView === 'month' &&
+            !this._adapter.sameMonthAndYear(oldActiveDate, this._clampedActiveDate)) {
+            if (this._adapter.isInNextMonth(oldActiveDate, this._clampedActiveDate)) {
+                this.calendarState('right');
+            }
+            else {
+                this.calendarState('left');
+            }
+        }
+    }
+    get currentView() {
+        return this._currentView;
+    }
+    set currentView(view) {
+        this._currentView = view;
+        this.viewChanged.emit(view);
+    }
+    /** The label for the current calendar view. */
+    get _yearLabel() {
+        return this._adapter.getYearName(this._activeDate);
+    }
+    get _monthYearLabel() {
+        if (this.currentView === 'multi-year') {
+            // The offset from the active year to the "slot" for the starting year is the
+            // *actual* first rendered year in the multi-year view, and the last year is
+            // just yearsPerPage - 1 away.
+            const activeYear = this._adapter.getYear(this._activeDate);
+            const minYearOfPage = activeYear - getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate);
+            const maxYearOfPage = minYearOfPage + yearsPerPage - 1;
+            const minYearName = this._adapter.getYearName(this._adapter.createDate(minYearOfPage, 0, 1));
+            const maxYearName = this._adapter.getYearName(this._adapter.createDate(maxYearOfPage, 0, 1));
+            return this._intl.formatYearRange(minYearName, maxYearName);
+        }
+        return this.currentView === 'month'
+            ? this._adapter.getMonthNames('long')[this._adapter.getMonth(this._activeDate)]
+            : this._adapter.getYearName(this._activeDate);
+    }
+    get _dateLabel() {
+        switch (this.type) {
+            case 'month': return this._adapter.getMonthNames('long')[this._adapter.getMonth(this._activeDate)];
+            default: return this._adapter.format(this._activeDate, this._dateFormats.display.popupHeaderDateLabel);
+        }
+    }
+    get periodButtonLabel() {
+        return this.currentView == 'month' ? this._intl.switchToMultiYearViewLabel : this._intl.switchToMonthViewLabel;
+    }
+    /** The label for the previous button. */
+    get prevButtonLabel() {
+        return {
+            'month': this._intl.prevMonthLabel,
+            'year': this._intl.prevYearLabel,
+            'multi-year': this._intl.prevMultiYearLabel
+        }[this.currentView];
+    }
+    /** The label for the next button. */
+    get nextButtonLabel() {
+        return {
+            'month': this._intl.nextMonthLabel,
+            'year': this._intl.nextYearLabel,
+            'multi-year': this._intl.nextMultiYearLabel
+        }[this.currentView];
+    }
+    get _hoursLabel() {
+        let hour = this._adapter.getHour(this._activeDate);
+        if (!!this.twelvehour) {
+            if (hour === 0) {
+                hour = 24;
+            }
+            hour = hour > 12 ? hour - 12 : hour;
+        }
+        return this._2digit(hour);
+    }
+    get _minutesLabel() {
+        return this._2digit(this._adapter.getMinute(this._activeDate));
+    }
+    get _ariaLabelNext() {
+        switch (this._currentView) {
+            case 'month': return this.ariaNextMonthLabel;
+            case 'year': return this.ariaNextYearLabel;
+            case 'multi-year': return this.ariaNextMultiYearLabel;
+            default: return '';
+        }
+    }
+    get _ariaLabelPrev() {
+        switch (this._currentView) {
+            case 'month': return this.ariaPrevMonthLabel;
+            case 'year': return this.ariaPrevYearLabel;
+            case 'multi-year': return this.ariaPrevMultiYearLabel;
+            default: return '';
+        }
+    }
+    ngAfterContentInit() {
+        this._activeDate = this.startAt || this._adapter.today();
+        this._selectAMPM(this._activeDate);
+        this._focusActiveCell();
+        if (this.type === 'year') {
+            this.currentView = 'multi-year';
+        }
+        else if (this.type === 'month') {
+            this.currentView = 'year';
+        }
+        else if (this.type === 'time') {
+            this.currentView = 'clock';
+        }
+        else {
+            this.currentView = this.startView || 'month';
+        }
+    }
+    ngOnDestroy() {
+        this._intlChanges.unsubscribe();
+    }
+    _userSelected() {
+        this._userSelection.emit();
+    }
+    /** Handles date selection in the month view. */
+    _dateSelected(date) {
+        if (this.type === 'date') {
+            if (!this._adapter.sameDate(date, this.selected) ||
+                !this.preventSameDateTimeSelection) {
+                this.selectedChange.emit(date);
+            }
+        }
+        else {
+            this._activeDate = date;
+            this.currentView = 'clock';
+        }
+    }
+    /** Handles month selection in the year view. */
+    _monthSelected(month) {
+        if (this.type === 'month') {
+            if (!this._adapter.sameMonthAndYear(month, this.selected) ||
+                !this.preventSameDateTimeSelection) {
+                this.selectedChange.emit(this._adapter.getFirstDateOfMonth(month));
+            }
+        }
+        else {
+            this._activeDate = month;
+            this.currentView = 'month';
+            this._clockView = 'hour';
+        }
+    }
+    /** Handles year selection in the multi year view. */
+    _yearSelected(year) {
+        if (this.type === 'year') {
+            if (!this._adapter.sameYear(year, this.selected) ||
+                !this.preventSameDateTimeSelection) {
+                const normalizedDate = this._adapter.createDatetime(this._adapter.getYear(year), 0, 1, 0, 0);
+                this.selectedChange.emit(normalizedDate);
+            }
+        }
+        else {
+            this._activeDate = year;
+            this.currentView = 'year';
+        }
+    }
+    _timeSelected(date) {
+        if (this._clockView !== 'minute') {
+            this._activeDate = this._updateDate(date);
+            this._clockView = 'minute';
+        }
+        else {
+            if (!this._adapter.sameDatetime(date, this.selected) ||
+                !this.preventSameDateTimeSelection) {
+                this.selectedChange.emit(date);
+            }
+        }
+    }
+    _onActiveDateChange(date) {
+        this._activeDate = date;
+    }
+    _updateDate(date) {
+        if (!!this.twelvehour) {
+            const HOUR = this._adapter.getHour(date);
+            if (HOUR === 12) {
+                if (this._AMPM === 'AM') {
+                    return this._adapter.addCalendarHours(date, -12);
+                }
+            }
+            else if (this._AMPM === 'PM') {
+                return this._adapter.addCalendarHours(date, 12);
+            }
+        }
+        return date;
+    }
+    _selectAMPM(date) {
+        if (this._adapter.getHour(date) > 11) {
+            this._AMPM = 'PM';
+        }
+        else {
+            this._AMPM = 'AM';
+        }
+    }
+    _ampmClicked(source) {
+        if (source === this._AMPM) {
+            return;
+        }
+        this._AMPM = source;
+        if (this._AMPM === 'AM') {
+            this._activeDate = this._adapter.addCalendarHours(this._activeDate, -12);
+        }
+        else {
+            this._activeDate = this._adapter.addCalendarHours(this._activeDate, 12);
+        }
+    }
+    _yearClicked() {
+        if (this.type === 'year' || this.multiYearSelector) {
+            this.currentView = 'multi-year';
+            return;
+        }
+        this.currentView = 'year';
+    }
+    _dateClicked() {
+        if (this.type !== 'month') {
+            this.currentView = 'month';
+        }
+    }
+    _hoursClicked() {
+        this.currentView = 'clock';
+        this._clockView = 'hour';
+    }
+    _minutesClicked() {
+        this.currentView = 'clock';
+        this._clockView = 'minute';
+    }
+    /** Handles user clicks on the previous button. */
+    _previousClicked() {
+        this._activeDate = this.currentView === 'month'
+            ? this._adapter.addCalendarMonths(this._activeDate, -1)
+            : this._adapter.addCalendarYears(this._activeDate, this.currentView === 'year' ? -1 : -yearsPerPage);
+    }
+    /** Handles user clicks on the next button. */
+    _nextClicked() {
+        this._activeDate = (this.currentView === 'month')
+            ? this._adapter.addCalendarMonths(this._activeDate, 1)
+            : this._adapter.addCalendarYears(this._activeDate, this.currentView === 'year' ? 1 : yearsPerPage);
+    }
+    /** Whether the previous period button is enabled. */
+    _previousEnabled() {
+        if (!this.minDate) {
+            return true;
+        }
+        return !this.minDate || !this._isSameView(this._activeDate, this.minDate);
+    }
+    /** Whether the next period button is enabled. */
+    _nextEnabled() {
+        return !this.maxDate || !this._isSameView(this._activeDate, this.maxDate);
+    }
+    /** Handles keydown events on the calendar body. */
+    _handleCalendarBodyKeydown(event) {
+        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent
+        // disabled ones from being selected. This may not be ideal, we should look into whether
+        // navigation should skip over disabled dates, and if so, how to implement that efficiently.
+        if (this.currentView === 'month') {
+            this._handleCalendarBodyKeydownInMonthView(event);
+        }
+        else if (this.currentView === 'year') {
+            this._handleCalendarBodyKeydownInYearView(event);
+        }
+        else if (this.currentView === 'multi-year') {
+            this._handleCalendarBodyKeydownInMultiYearView(event);
+        }
+        else {
+            this._handleCalendarBodyKeydownInClockView(event);
+        }
+    }
+    _focusActiveCell() {
+        this._ngZone.runOutsideAngular(() => {
+            this._ngZone.onStable
+                .asObservable()
+                .pipe(first())
+                .subscribe(() => this._elementRef.nativeElement.focus());
+        });
+    }
+    _calendarStateDone() {
+        this._calendarState = '';
+    }
+    /** Whether the two dates represent the same view in the current view mode (month or year). */
+    _isSameView(date1, date2) {
+        if (this.currentView === 'month') {
+            return (this._adapter.getYear(date1) === this._adapter.getYear(date2) &&
+                this._adapter.getMonth(date1) === this._adapter.getMonth(date2));
+        }
+        if (this.currentView === 'year') {
+            return this._adapter.getYear(date1) === this._adapter.getYear(date2);
+        }
+        // Otherwise we are in 'multi-year' view.
+        return isSameMultiYearView(this._adapter, date1, date2, this.minDate, this.maxDate);
+    }
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    _handleCalendarBodyKeydownInMonthView(event) {
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+                this._activeDate = this._adapter.addCalendarDays(this._activeDate, -1);
+                break;
+            case RIGHT_ARROW:
+                this._activeDate = this._adapter.addCalendarDays(this._activeDate, 1);
+                break;
+            case UP_ARROW:
+                this._activeDate = this._adapter.addCalendarDays(this._activeDate, -7);
+                break;
+            case DOWN_ARROW:
+                this._activeDate = this._adapter.addCalendarDays(this._activeDate, 7);
+                break;
+            case HOME:
+                this._activeDate = this._adapter.addCalendarDays(this._activeDate, 1 - this._adapter.getDate(this._activeDate));
+                break;
+            case END:
+                this._activeDate = this._adapter.addCalendarDays(this._activeDate, this._adapter.getNumDaysInMonth(this._activeDate) - this._adapter.getDate(this._activeDate));
+                break;
+            case PAGE_UP:
+                this._activeDate = event.altKey
+                    ? this._adapter.addCalendarYears(this._activeDate, -1)
+                    : this._adapter.addCalendarMonths(this._activeDate, -1);
+                break;
+            case PAGE_DOWN:
+                this._activeDate = event.altKey
+                    ? this._adapter.addCalendarYears(this._activeDate, 1)
+                    : this._adapter.addCalendarMonths(this._activeDate, 1);
+                break;
+            case ENTER:
+                if (this._dateFilterForViews(this._activeDate)) {
+                    this._dateSelected(this._activeDate);
+                    // Prevent unexpected default actions such as form submission.
+                    event.preventDefault();
+                }
+                return;
+            default:
+                // Don't prevent default or focus active cell on keys that we don't explicitly handle.
+                return;
+        }
+        // Prevent unexpected default actions such as form submission.
+        event.preventDefault();
+    }
+    /** Handles keydown events on the calendar body when calendar is in year view. */
+    _handleCalendarBodyKeydownInYearView(event) {
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, -1);
+                break;
+            case RIGHT_ARROW:
+                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, 1);
+                break;
+            case UP_ARROW:
+                this._activeDate = this._prevMonthInSameCol(this._activeDate);
+                break;
+            case DOWN_ARROW:
+                this._activeDate = this._nextMonthInSameCol(this._activeDate);
+                break;
+            case HOME:
+                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, -this._adapter.getMonth(this._activeDate));
+                break;
+            case END:
+                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, 11 - this._adapter.getMonth(this._activeDate));
+                break;
+            case PAGE_UP:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? -10 : -1);
+                break;
+            case PAGE_DOWN:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? 10 : 1);
+                break;
+            case ENTER:
+                this._monthSelected(this._activeDate);
+                break;
+            default:
+                // Don't prevent default or focus active cell on keys that we don't explicitly handle.
+                return;
+        }
+        // Prevent unexpected default actions such as form submission.
+        event.preventDefault();
+    }
+    /** Handles keydown events on the calendar body when calendar is in multi-year view. */
+    _handleCalendarBodyKeydownInMultiYearView(event) {
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, -1);
+                break;
+            case RIGHT_ARROW:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, 1);
+                break;
+            case UP_ARROW:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, -yearsPerRow);
+                break;
+            case DOWN_ARROW:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, yearsPerRow);
+                break;
+            case HOME:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, -getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate));
+                break;
+            case END:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, yearsPerPage - getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate) - 1);
+                break;
+            case PAGE_UP:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);
+                break;
+            case PAGE_DOWN:
+                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);
+                break;
+            case ENTER:
+                this._yearSelected(this._activeDate);
+                break;
+            default:
+                // Don't prevent default or focus active cell on keys that we don't explicitly handle.
+                return;
+        }
+    }
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    _handleCalendarBodyKeydownInClockView(event) {
+        switch (event.keyCode) {
+            case UP_ARROW:
+                this._activeDate = this._clockView === 'hour'
+                    ? this._adapter.addCalendarHours(this._activeDate, 1)
+                    : this._adapter.addCalendarMinutes(this._activeDate, 1);
+                break;
+            case DOWN_ARROW:
+                this._activeDate = this._clockView === 'hour'
+                    ? this._adapter.addCalendarHours(this._activeDate, -1)
+                    : this._adapter.addCalendarMinutes(this._activeDate, -1);
+                break;
+            case ENTER:
+                this._timeSelected(this._activeDate);
+                return;
+            default:
+                // Don't prevent default or focus active cell on keys that we don't explicitly handle.
+                return;
+        }
+        // Prevent unexpected default actions such as form submission.
+        event.preventDefault();
+    }
+    /**
+     * Determine the date for the month that comes before the given month in the same column in the
+     * calendar table.
+     */
+    _prevMonthInSameCol(date) {
+        // Determine how many months to jump forward given that there are 2 empty slots at the beginning of each year.
+        const increment = this._adapter.getMonth(date) <= 4 ? -5 : this._adapter.getMonth(date) >= 7 ? -7 : -12;
+        return this._adapter.addCalendarMonths(date, increment);
+    }
+    /**
+     * Determine the date for the month that comes after the given month in the same column in the
+     * calendar table.
+     */
+    _nextMonthInSameCol(date) {
+        // Determine how many months to jump forward given that there are 2 empty slots at the beginning of each year.
+        const increment = this._adapter.getMonth(date) <= 4 ? 7 : this._adapter.getMonth(date) >= 7 ? 5 : 12;
+        return this._adapter.addCalendarMonths(date, increment);
+    }
+    calendarState(direction) {
+        this._calendarState = direction;
+    }
+    _2digit(n) {
+        return ('00' + n).slice(-2);
+    }
+};
+GIPIDatetimepickerCalendarComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: MatDatepickerIntl },
+    { type: NgZone },
+    { type: GIPIDatetimeAdapter, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [GIPI_DATETIME_FORMATS,] }] },
+    { type: ChangeDetectorRef }
+];
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean)
+], GIPIDatetimepickerCalendarComponent.prototype, "multiYearSelector", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPIDatetimepickerCalendarComponent.prototype, "startView", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean)
+], GIPIDatetimepickerCalendarComponent.prototype, "twelvehour", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], GIPIDatetimepickerCalendarComponent.prototype, "timeInterval", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Function)
+], GIPIDatetimepickerCalendarComponent.prototype, "dateFilter", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaNextMonthLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaPrevMonthLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaNextYearLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaPrevYearLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaNextMultiYearLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "ariaPrevMultiYearLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "preventSameDateTimeSelection", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String),
+    __metadata("design:paramtypes", [String])
+], GIPIDatetimepickerCalendarComponent.prototype, "type", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerCalendarComponent.prototype, "startAt", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerCalendarComponent.prototype, "selected", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerCalendarComponent.prototype, "minDate", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerCalendarComponent.prototype, "maxDate", null);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], GIPIDatetimepickerCalendarComponent.prototype, "selectedChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], GIPIDatetimepickerCalendarComponent.prototype, "viewChanged", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerCalendarComponent.prototype, "_userSelection", void 0);
+GIPIDatetimepickerCalendarComponent = __decorate([
+    Component({
+        selector: 'gipi-mat-datetime-picker-calendar',
+        template: "<div class=\"gipi-mat-datetime-picker-calendar-header\">\n    <div class=\"gipi-mat-datetime-picker-calendar-controls\">\n        <div *ngIf=\"type !== 'time'\"\n             role=\"button\"\n             cdkAriaLive=\"polite\"\n             class=\"gipi-mat-datetime-picker-calendar-period-button\"\n             [class.active]=\"currentView === 'year' || currentView === 'multi-year'\"\n             [attr.aria-label]=\"periodButtonLabel\"\n             (click)=\"_yearClicked()\">\n            {{ _yearLabel }}\n\n            <div *ngIf=\"multiYearSelector || type === 'year'\"\n                 class=\"gipi-mat-datetime-picker-calendar-arrow\"\n                 [class.gipi-mat-datetime-picker-calendar-invert]=\"currentView != 'month'\">\n            </div>\n        </div>\n\n        <div class=\"gipi-mat-datetime-picker-calendar-spacer\"> </div>\n\n        <button mat-icon-button\n                type=\"button\"\n                class=\"gipi-mat-datetime-picker-calendar-previous-button\"\n                [disabled]=\"!_previousEnabled()\"\n                (click)=\"_previousClicked()\"\n                [attr.aria-label]=\"prevButtonLabel\">\n        </button>\n\n        <button mat-icon-button\n                type=\"button\"\n                class=\"gipi-mat-datetime-picker-calendar-next-button\"\n                [disabled]=\"!_nextEnabled()\"\n                (click)=\"_nextClicked()\"\n                [attr.aria-label]=\"nextButtonLabel\">\n        </button>\n    </div>\n\n    <div class=\"gipi-mat-datetime-picker-calendar-header-date-time\">\n        <span *ngIf=\"type !== 'time' && type !== 'year'\"\n              role=\"button\"\n              class=\"gipi-mat-datetime-picker-calendar-header-date\"\n              [class.active]=\"currentView === 'month'\"\n              [class.not-clickable]=\"type === 'month'\"\n              (click)=\"_dateClicked()\">\n            {{ _dateLabel }}\n        </span>\n        <span *ngIf=\"type.endsWith('time')\"\n              class=\"gipi-mat-datetime-picker-calendar-header-time\"\n              [class.active]=\"currentView === 'clock'\">\n            <span role=\"button\"\n                  class=\"gipi-mat-datetime-picker-calendar-header-hours\"\n                  [class.active]=\"currentView === 'clock' && _clockView === 'hour'\"\n                  (click)=\"_hoursClicked()\">\n                {{ _hoursLabel }}\n            </span>\n            :\n            <span role=\"button\"\n                  class=\"gipi-mat-datetime-picker-calendar-header-minutes\"\n                  [class.active]=\"currentView === 'clock' && _clockView === 'minute'\"\n                  (click)=\"_minutesClicked()\">\n                {{ _minutesLabel }}\n            </span>\n            <br />\n            <span *ngIf=\"twelvehour\"\n                  class=\"gipi-mat-datetime-picker-calendar-header-ampm-container\">\n                <span class=\"gipi-mat-datetime-picker-calendar-header-ampm\"\n                      [class.active]=\"currentView === 'clock' && _AMPM === 'AM'\"\n                      (click)=\"_ampmClicked('AM')\">\n                    AM\n                </span>\n                /\n                <span class=\"gipi-mat-datetime-picker-calendar-header-ampm\"\n                      [class.active]=\"currentView === 'clock' && _AMPM === 'PM'\"\n                      (click)=\"_ampmClicked('PM')\">\n                    PM\n                </span>\n            </span>\n        </span>\n    </div>\n</div>\n\n<div [ngSwitch]=\"currentView\"\n     class=\"gipi-mat-datetime-picker-calendar-content\">\n    <!-- <div *ngIf=\"currentView === 'month' || currentView === 'year' || currentView === 'multi-year'\"\n         class=\"mat-month-content\">\n        <div class=\"gipi-mat-datetime-picker-calendar-controls\">\n            <div (click)=\"_previousClicked()\"\n                 [attr.aria-disabled]=\"!_previousEnabled()\"\n                 [attr.aria-label]=\"_ariaLabelPrev\"\n                 [class.disabled]=\"!_previousEnabled()\"\n                 class=\"gipi-mat-datetime-picker-calendar-previous-button\"\n                 role=\"button\">\n                <svg height=\"24\"\n                     viewBox=\"0 0 24 24\"\n                     width=\"24\">\n                    <path d=\"M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z\"></path>\n                </svg>\n            </div>\n            <div (@slideCalendar.done)=\"_calendarStateDone()\"\n                 [@slideCalendar]=\"_calendarState\"\n                 class=\"gipi-mat-datetime-picker-calendar-period-button\">\n                <strong>{{ _monthYearLabel }}</strong>\n            </div>\n            <div (click)=\"_nextClicked()\"\n                 [attr.aria-disabled]=\"!_nextEnabled()\"\n                 [attr.aria-label]=\"_ariaLabelNext\"\n                 [class.disabled]=\"!_nextEnabled()\"\n                 class=\"gipi-mat-datetime-picker-calendar-next-button\"\n                 role=\"button\">\n                <svg height=\"24\"\n                     viewBox=\"0 0 24 24\"\n                     width=\"24\">\n                    <path d=\"M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z\"></path>\n                </svg>\n            </div>\n        </div>\n    </div> -->\n\n    <gipi-mat-datetime-picker-month-view (_userSelection)=\"_userSelected()\"\n                                         (selectedChange)=\"_dateSelected($event)\"\n                                         *ngSwitchCase=\"'month'\"\n                                         [activeDate]=\"_activeDate\"\n                                         [dateFilter]=\"_dateFilterForViews\"\n                                         [selected]=\"selected\"\n                                         [type]=\"type\">\n    </gipi-mat-datetime-picker-month-view>\n    <gipi-mat-datetime-picker-year-view (_userSelection)=\"_userSelected()\"\n                                        (selectedChange)=\"_monthSelected($event)\"\n                                        *ngSwitchCase=\"'year'\"\n                                        [activeDate]=\"_activeDate\"\n                                        [dateFilter]=\"_dateFilterForViews\"\n                                        [selected]=\"selected\"\n                                        [type]=\"type\">\n    </gipi-mat-datetime-picker-year-view>\n    <gipi-mat-datetime-picker-multi-year-view (_userSelection)=\"_userSelected()\"\n                                              (selectedChange)=\"_yearSelected($event)\"\n                                              *ngSwitchCase=\"'multi-year'\"\n                                              [activeDate]=\"_activeDate\"\n                                              [dateFilter]=\"_dateFilterForViews\"\n                                              [maxDate]=\"maxDate\"\n                                              [minDate]=\"minDate\"\n                                              [selected]=\"selected\"\n                                              [type]=\"type\">\n    </gipi-mat-datetime-picker-multi-year-view>\n    <gipi-mat-datetime-picker-clock (_userSelection)=\"_userSelected()\"\n                                    (activeDateChange)=\"_onActiveDateChange($event)\"\n                                    (selectedChange)=\"_timeSelected($event)\"\n                                    *ngSwitchDefault\n                                    [dateFilter]=\"dateFilter\"\n                                    [interval]=\"timeInterval\"\n                                    [maxDate]=\"maxDate\"\n                                    [minDate]=\"minDate\"\n                                    [selected]=\"_activeDate\"\n                                    [startView]=\"_clockView\"\n                                    [twelvehour]=\"twelvehour\">\n    </gipi-mat-datetime-picker-clock>\n</div>",
+        animations: [slideCalendar],
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        host: {
+            '[class.gipi-mat-datetime-picker-calendar]': 'true',
+            '[attr.aria-label]': 'ariaLabel',
+            role: 'dialog',
+            tabindex: '0',
+            '(keydown)': '_handleCalendarBodyKeydown($event)',
+        },
+        styles: [".gipi-mat-datetime-picker-calendar{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;display:block;outline:0}.gipi-mat-datetime-picker-calendar[mode=landscape]{display:flex}.gipi-mat-datetime-picker-calendar-header{padding:8px 8px 0;font-size:14px;box-sizing:border-box}[mode=landscape] .gipi-mat-datetime-picker-calendar-header{width:150px;min-width:150px}.gipi-mat-datetime-picker-calendar-controls{display:flex;margin:5% calc(33% / 7 - 16px)}.gipi-mat-datetime-picker-calendar-controls .mat-icon-button:hover .mat-button-focus-overlay{opacity:.04}.gipi-mat-datetime-picker-calendar-spacer{flex:1 1 auto}.gipi-mat-datetime-picker-calendar-period-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:0;border:none;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:0;line-height:36px;padding:0 16px;border-radius:4px}.gipi-mat-datetime-picker-calendar-arrow{display:inline-block;width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top-width:5px;border-top-style:solid;margin:0 0 0 5px;vertical-align:middle}.gipi-mat-datetime-picker-calendar-arrow.gipi-mat-datetime-picker-calendar-invert{transform:rotate(180deg)}[dir=rtl] .gipi-mat-datetime-picker-calendar-arrow{margin:0 5px 0 0}.gipi-mat-datetime-picker-calendar-next-button::after,.gipi-mat-datetime-picker-calendar-previous-button::after{top:0;left:0;right:0;bottom:0;position:absolute;content:'';margin:15.5px;border:0 solid currentColor;border-top-width:2px}[dir=rtl] .gipi-mat-datetime-picker-calendar-next-button,[dir=rtl] .gipi-mat-datetime-picker-calendar-previous-button{transform:rotate(180deg)}.gipi-mat-datetime-picker-calendar-previous-button::after{border-left-width:2px;transform:translateX(2px) rotate(-45deg)}.gipi-mat-datetime-picker-calendar-next-button::after{border-right-width:2px;transform:translateX(-2px) rotate(45deg)}.gipi-mat-datetime-picker-calendar-header-date-time{display:flex;flex-direction:row;align-items:center;justify-content:space-between;width:100%;margin-top:6px;font-weight:500;white-space:nowrap}[mode=landscape] .gipi-mat-datetime-picker-calendar-header-date-time{white-space:normal;word-wrap:break-word;margin-top:0}.gipi-mat-datetime-picker-calendar-header-ampm-container{font-size:.77em}.gipi-mat-datetime-picker-calendar-header-date{display:flex;align-items:center;justify-content:center;border-radius:6px;padding-inline:1rem;font-size:14px;line-height:36px;font-weight:600;transition:.2s}.gipi-mat-datetime-picker-calendar-header-date:not(.active){cursor:pointer;opacity:.6}.gipi-mat-datetime-picker-calendar-header-date:not(.active):hover{background:#f5f5f6;opacity:1}.gipi-mat-datetime-picker-calendar-header-date.active{cursor:pointer;background-color:#f3e7e7;color:#e0313e;opacity:1}.gipi-mat-datetime-picker-calendar-header-date.active:hover{background-color:#e0313e;color:#f3e7e7}.gipi-mat-datetime-picker-calendar-header-date.not-clickable{cursor:initial}.gipi-mat-datetime-picker-calendar-header-ampm,.gipi-mat-datetime-picker-calendar-header-hours,.gipi-mat-datetime-picker-calendar-header-minutes{display:flex;align-items:center;justify-content:center;border-radius:6px;width:36px;height:36px;transition:.2s}.gipi-mat-datetime-picker-calendar-header-ampm:not(.active),.gipi-mat-datetime-picker-calendar-header-hours:not(.active),.gipi-mat-datetime-picker-calendar-header-minutes:not(.active){cursor:pointer;opacity:.6}.gipi-mat-datetime-picker-calendar-header-ampm:not(.active):hover,.gipi-mat-datetime-picker-calendar-header-hours:not(.active):hover,.gipi-mat-datetime-picker-calendar-header-minutes:not(.active):hover{background:#f5f5f6;opacity:1}.gipi-mat-datetime-picker-calendar-header-ampm.active,.gipi-mat-datetime-picker-calendar-header-hours.active,.gipi-mat-datetime-picker-calendar-header-minutes.active{cursor:pointer;background-color:#f3e7e7;color:#e0313e;opacity:1}.gipi-mat-datetime-picker-calendar-header-ampm.active:hover,.gipi-mat-datetime-picker-calendar-header-hours.active:hover,.gipi-mat-datetime-picker-calendar-header-minutes.active:hover{background-color:#e0313e;color:#f3e7e7}.gipi-mat-datetime-picker-calendar-header-ampm.not-clickable,.gipi-mat-datetime-picker-calendar-header-hours.not-clickable,.gipi-mat-datetime-picker-calendar-header-minutes.not-clickable{cursor:initial}.gipi-mat-datetime-picker-calendar-header-time{display:flex;align-items:center;justify-content:center;gap:1px;font-size:24px;line-height:36px;padding-left:8px}.gipi-mat-datetime-picker-calendar-header-time:not(.active){opacity:.6}[mode=landscape] .gipi-mat-datetime-picker-calendar-header-time{display:block;padding-left:0}.gipi-mat-datetime-picker-calendar-content{width:100%;padding:0 8px 8px;outline:0;box-sizing:border-box;overflow:hidden}[mode=landscape] .gipi-mat-datetime-picker-calendar-content{padding-top:8px}.gipi-mat-datetime-picker-calendar-controls{display:flex;justify-content:space-between}.gipi-mat-datetime-picker-calendar-next-button,.gipi-mat-datetime-picker-calendar-previous-button{position:relative;display:inline-block;width:48px;height:48px;padding:12px;outline:0;border:0;cursor:pointer;background:0 0;box-sizing:border-box}.gipi-mat-datetime-picker-calendar-next-button.disabled,.gipi-mat-datetime-picker-calendar-previous-button.disabled{color:rgba(0,0,0,.38);pointer-events:none}.gipi-mat-datetime-picker-calendar-next-button svg,.gipi-mat-datetime-picker-calendar-previous-button svg{fill:currentColor;vertical-align:top}.gipi-mat-datetime-picker-calendar-table{border-spacing:0;border-collapse:collapse;width:100%}.gipi-mat-datetime-picker-calendar-table-header{color:rgba(0,0,0,.38)}.gipi-mat-datetime-picker-calendar-table-header th{text-align:center;font-size:11px;padding:0 0 8px}.gipi-mat-datetime-picker-calendar-table-header-divider{position:relative;height:1px}.gipi-mat-datetime-picker-calendar-table-header-divider::after{content:'';position:absolute;top:0;left:-8px;right:-8px;height:1px}@media (min-width:480px){.gipi-mat-datetime-picker-calendar[mode=auto]{display:flex}.gipi-mat-datetime-picker-calendar[mode=auto] .gipi-mat-datetime-picker-calendar-header{width:150px;min-width:150px}.gipi-mat-datetime-picker-calendar[mode=auto] .gipi-mat-datetime-picker-calendar-header-date-time{white-space:normal;word-wrap:break-word}.gipi-mat-datetime-picker-calendar[mode=auto] .gipi-mat-datetime-picker-calendar-header-time{display:block;padding-left:0}.gipi-mat-datetime-picker-calendar[mode=auto] .gipi-mat-datetime-picker-calendar-content{padding-top:8px}}"]
+    }),
+    __param(3, Optional()),
+    __param(4, Optional()), __param(4, Inject(GIPI_DATETIME_FORMATS)),
+    __metadata("design:paramtypes", [ElementRef,
+        MatDatepickerIntl,
+        NgZone,
+        GIPIDatetimeAdapter, Object, ChangeDetectorRef])
+], GIPIDatetimepickerCalendarComponent);
+export { GIPIDatetimepickerCalendarComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/calendar.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, UP_ARROW, } from '@angular/cdk/keycodes';\nimport { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Inject, Input, NgZone, OnDestroy, Optional, Output, ViewEncapsulation, } from '@angular/core';\nimport { MatDatepickerIntl } from '@angular/material/datepicker';\nimport { Subscription } from 'rxjs';\nimport { first } from 'rxjs/operators';\n\nimport { GIPIClockView } from './clock';\nimport { slideCalendar } from './datetimepicker-animations';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';\nimport { GIPIDatetimepickerType } from './datetimepicker-type';\nimport { getActiveOffset, isSameMultiYearView, yearsPerPage, yearsPerRow, } from './multi-year-view';\nimport { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';\nimport { GIPI_DATETIME_FORMATS, GIPIDatetimeFormats, } from './shared/adapter/datetime-formats';\n\nexport type GIPICalendarView = 'clock' | 'month' | 'year' | 'multi-year';\n\n/**\n * A calendar that is used as part of the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-datetime-picker-calendar',\n    templateUrl: 'calendar.html',\n    styleUrls: ['calendar.scss'],\n    animations: [slideCalendar],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    host: {\n        '[class.gipi-mat-datetime-picker-calendar]': 'true',\n        '[attr.aria-label]': 'ariaLabel',\n        role: 'dialog',\n        tabindex: '0',\n        '(keydown)': '_handleCalendarBodyKeydown($event)',\n    },\n})\nexport class GIPIDatetimepickerCalendarComponent<D> implements AfterContentInit, OnDestroy {\n\n    _AMPM: string;\n    _clockView: GIPIClockView = 'hour';\n    _calendarState: string;\n\n    private _intlChanges: Subscription;\n    private _clampedActiveDate: D;\n\n    /** Active multi year view when click on year. */\n    @Input() multiYearSelector: boolean = true;\n\n    /** Whether the calendar should be started in month or year view. */\n    @Input() startView: GIPICalendarView = 'month';\n    @Input() twelvehour: boolean = false;\n    @Input() timeInterval: number = 1;\n\n    /** A function used to filter which dates are selectable. */\n    @Input() dateFilter: (date: D, type: GIPIDatetimepickerFilterType) => boolean;\n    @Input() ariaLabel = 'Use arrow keys to navigate';\n    @Input() ariaNextMonthLabel = 'Next month';\n    @Input() ariaPrevMonthLabel = 'Previous month';\n    @Input() ariaNextYearLabel = 'Next year';\n    @Input() ariaPrevYearLabel = 'Previous year';\n    @Input() ariaNextMultiYearLabel = 'Next year range';\n    @Input() ariaPrevMultiYearLabel = 'Previous year range';\n\n    /** Prevent user to select same date time */\n    @Input() preventSameDateTimeSelection = false;\n\n    private _type: GIPIDatetimepickerType = 'date';\n    @Input() get type(): GIPIDatetimepickerType {\n        return this._type;\n    }\n    set type(value: GIPIDatetimepickerType) {\n        this._type = value || 'date';\n        if (this.type === 'year') {\n            this.multiYearSelector = true;\n        }\n    }\n\n    /** A date representing the period (month or year) to start the calendar in. */\n    private _startAt: D | null;\n    @Input() get startAt(): D | null {\n        return this._startAt;\n    }\n    set startAt(value: D | null) {\n        this._startAt = this._adapter.getValidDateOrNull(value);\n    }\n\n    /** The currently selected date. */\n    private _selected: D | null;\n    @Input() get selected(): D | null {\n        return this._selected;\n    }\n\n    set selected(value: D | null) {\n        this._selected = this._adapter.getValidDateOrNull(value);\n    }\n\n    /** The minimum selectable date. */\n    private _minDate: D | null;\n    @Input() get minDate(): D | null {\n        return this._minDate;\n    }\n    set minDate(value: D | null) {\n        this._minDate = this._adapter.getValidDateOrNull(value);\n    }\n\n    /** The maximum selectable date. */\n    private _maxDate: D | null;\n    @Input() get maxDate(): D | null {\n        return this._maxDate;\n    }\n    set maxDate(value: D | null) {\n        this._maxDate = this._adapter.getValidDateOrNull(value);\n    }\n\n    /** Emits when the currently selected date changes. */\n    @Output() selectedChange: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Emits when the view has been changed. **/\n    @Output() viewChanged: EventEmitter<GIPICalendarView> = new EventEmitter<GIPICalendarView>();\n    @Output() _userSelection = new EventEmitter<void>();\n\n    /** The current active date. This determines which time period is shown and which date is highlighted when using keyboard navigation. */\n    get _activeDate(): D {\n        return this._clampedActiveDate;\n    }\n    set _activeDate(value: D) {\n        const oldActiveDate = this._clampedActiveDate;\n        this._clampedActiveDate = this._adapter.clampDate(value, this.minDate, this.maxDate);\n        if (\n            oldActiveDate &&\n            this._clampedActiveDate &&\n            this.currentView === 'month' &&\n            !this._adapter.sameMonthAndYear(oldActiveDate, this._clampedActiveDate)\n        ) {\n            if (this._adapter.isInNextMonth(oldActiveDate, this._clampedActiveDate)) {\n                this.calendarState('right');\n            } else {\n                this.calendarState('left');\n            }\n        }\n    }\n\n    /** Whether the calendar is in month view. */\n    _currentView: GIPICalendarView;\n    get currentView(): GIPICalendarView {\n        return this._currentView;\n    }\n    set currentView(view: GIPICalendarView) {\n        this._currentView = view;\n        this.viewChanged.emit(view);\n    }\n\n    /** The label for the current calendar view. */\n    get _yearLabel(): string {\n        return this._adapter.getYearName(this._activeDate);\n    }\n\n    get _monthYearLabel(): string {\n        if (this.currentView === 'multi-year') {\n            // The offset from the active year to the \"slot\" for the starting year is the\n            // *actual* first rendered year in the multi-year view, and the last year is\n            // just yearsPerPage - 1 away.\n            const activeYear = this._adapter.getYear(this._activeDate);\n            const minYearOfPage = activeYear - getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate);\n            const maxYearOfPage = minYearOfPage + yearsPerPage - 1;\n            const minYearName = this._adapter.getYearName(this._adapter.createDate(minYearOfPage, 0, 1));\n            const maxYearName = this._adapter.getYearName(this._adapter.createDate(maxYearOfPage, 0, 1));\n            return this._intl.formatYearRange(minYearName, maxYearName);\n        }\n\n        return this.currentView === 'month'\n            ? this._adapter.getMonthNames('long')[this._adapter.getMonth(this._activeDate)]\n            : this._adapter.getYearName(this._activeDate);\n    }\n\n    get _dateLabel(): string {\n        switch (this.type) {\n            case 'month': return this._adapter.getMonthNames('long')[this._adapter.getMonth(this._activeDate)];\n            default: return this._adapter.format(this._activeDate, this._dateFormats.display.popupHeaderDateLabel);\n        }\n    }\n\n    get periodButtonLabel(): string {\n        return this.currentView == 'month' ? this._intl.switchToMultiYearViewLabel : this._intl.switchToMonthViewLabel;\n    }\n\n    /** The label for the previous button. */\n    get prevButtonLabel(): string {\n        return {\n            'month': this._intl.prevMonthLabel,\n            'year': this._intl.prevYearLabel,\n            'multi-year': this._intl.prevMultiYearLabel\n        }[this.currentView];\n    }\n\n    /** The label for the next button. */\n    get nextButtonLabel(): string {\n        return {\n            'month': this._intl.nextMonthLabel,\n            'year': this._intl.nextYearLabel,\n            'multi-year': this._intl.nextMultiYearLabel\n        }[this.currentView];\n    }\n\n    get _hoursLabel(): string {\n        let hour = this._adapter.getHour(this._activeDate);\n        if (!!this.twelvehour) {\n            if (hour === 0) {\n                hour = 24;\n            }\n            hour = hour > 12 ? hour - 12 : hour;\n        }\n        return this._2digit(hour);\n    }\n\n    get _minutesLabel(): string {\n        return this._2digit(this._adapter.getMinute(this._activeDate));\n    }\n\n    get _ariaLabelNext(): string {\n        switch (this._currentView) {\n            case 'month': return this.ariaNextMonthLabel;\n            case 'year': return this.ariaNextYearLabel;\n            case 'multi-year': return this.ariaNextMultiYearLabel;\n            default: return '';\n        }\n    }\n\n    get _ariaLabelPrev(): string {\n        switch (this._currentView) {\n            case 'month': return this.ariaPrevMonthLabel;\n            case 'year': return this.ariaPrevYearLabel;\n            case 'multi-year': return this.ariaPrevMultiYearLabel;\n            default: return '';\n        }\n    }\n\n    constructor(\n        private _elementRef: ElementRef,\n        private _intl: MatDatepickerIntl,\n        private _ngZone: NgZone,\n        @Optional() private _adapter: GIPIDatetimeAdapter<D>,\n        @Optional() @Inject(GIPI_DATETIME_FORMATS) private _dateFormats: GIPIDatetimeFormats,\n        changeDetectorRef: ChangeDetectorRef\n    ) {\n        if (!this._adapter) {\n            throw createMissingDateImplError('GIPIDatetimeAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');\n        }\n        this._intlChanges = _intl.changes.subscribe(() => changeDetectorRef.markForCheck());\n    }\n\n    ngAfterContentInit() {\n        this._activeDate = this.startAt || this._adapter.today();\n        this._selectAMPM(this._activeDate);\n        this._focusActiveCell();\n        if (this.type === 'year') {\n            this.currentView = 'multi-year';\n        } else if (this.type === 'month') {\n            this.currentView = 'year';\n        } else if (this.type === 'time') {\n            this.currentView = 'clock';\n        } else {\n            this.currentView = this.startView || 'month';\n        }\n    }\n\n    ngOnDestroy() {\n        this._intlChanges.unsubscribe();\n    }\n\n    /** Date filter for the month and year views. */\n    _dateFilterForViews = (date: D) => {\n        return (\n            !!date &&\n            (!this.dateFilter || this.dateFilter(date, GIPIDatetimepickerFilterType.DATE)) &&\n            (!this.minDate || this._adapter.compareDate(date, this.minDate) >= 0) &&\n            (!this.maxDate || this._adapter.compareDate(date, this.maxDate) <= 0)\n        );\n    };\n\n    _userSelected(): void {\n        this._userSelection.emit();\n    }\n\n    /** Handles date selection in the month view. */\n    _dateSelected(date: D): void {\n        if (this.type === 'date') {\n            if (\n                !this._adapter.sameDate(date, this.selected) ||\n                !this.preventSameDateTimeSelection\n            ) {\n                this.selectedChange.emit(date);\n            }\n        } else {\n            this._activeDate = date;\n            this.currentView = 'clock';\n        }\n    }\n\n    /** Handles month selection in the year view. */\n    _monthSelected(month: D): void {\n        if (this.type === 'month') {\n            if (\n                !this._adapter.sameMonthAndYear(month, this.selected) ||\n                !this.preventSameDateTimeSelection\n            ) {\n                this.selectedChange.emit(this._adapter.getFirstDateOfMonth(month));\n            }\n        } else {\n            this._activeDate = month;\n            this.currentView = 'month';\n            this._clockView = 'hour';\n        }\n    }\n\n    /** Handles year selection in the multi year view. */\n    _yearSelected(year: D): void {\n        if (this.type === 'year') {\n            if (\n                !this._adapter.sameYear(year, this.selected) ||\n                !this.preventSameDateTimeSelection\n            ) {\n                const normalizedDate = this._adapter.createDatetime(this._adapter.getYear(year), 0, 1, 0, 0);\n                this.selectedChange.emit(normalizedDate);\n            }\n        } else {\n            this._activeDate = year;\n            this.currentView = 'year';\n        }\n    }\n\n    _timeSelected(date: D): void {\n        if (this._clockView !== 'minute') {\n            this._activeDate = this._updateDate(date);\n            this._clockView = 'minute';\n        } else {\n            if (\n                !this._adapter.sameDatetime(date, this.selected) ||\n                !this.preventSameDateTimeSelection\n            ) {\n                this.selectedChange.emit(date);\n            }\n        }\n    }\n\n    _onActiveDateChange(date: D) {\n        this._activeDate = date;\n    }\n\n    _updateDate(date: D): D {\n        if (!!this.twelvehour) {\n            const HOUR = this._adapter.getHour(date);\n            if (HOUR === 12) {\n                if (this._AMPM === 'AM') {\n                    return this._adapter.addCalendarHours(date, -12);\n                }\n            } else if (this._AMPM === 'PM') {\n                return this._adapter.addCalendarHours(date, 12);\n            }\n        }\n        return date;\n    }\n\n    _selectAMPM(date: D) {\n        if (this._adapter.getHour(date) > 11) {\n            this._AMPM = 'PM';\n        } else {\n            this._AMPM = 'AM';\n        }\n    }\n\n    _ampmClicked(source: string): void {\n        if (source === this._AMPM) {\n            return;\n        }\n        this._AMPM = source;\n        if (this._AMPM === 'AM') {\n            this._activeDate = this._adapter.addCalendarHours(this._activeDate, -12);\n        } else {\n            this._activeDate = this._adapter.addCalendarHours(this._activeDate, 12);\n        }\n    }\n\n    _yearClicked(): void {\n        if (this.type === 'year' || this.multiYearSelector) {\n            this.currentView = 'multi-year';\n            return;\n        }\n        this.currentView = 'year';\n    }\n\n    _dateClicked(): void {\n        if (this.type !== 'month') {\n            this.currentView = 'month';\n        }\n    }\n\n    _hoursClicked(): void {\n        this.currentView = 'clock';\n        this._clockView = 'hour';\n    }\n\n    _minutesClicked(): void {\n        this.currentView = 'clock';\n        this._clockView = 'minute';\n    }\n\n    /** Handles user clicks on the previous button. */\n    _previousClicked(): void {\n        this._activeDate = this.currentView === 'month'\n            ? this._adapter.addCalendarMonths(this._activeDate, -1)\n            : this._adapter.addCalendarYears(this._activeDate, this.currentView === 'year' ? -1 : -yearsPerPage);\n    }\n\n    /** Handles user clicks on the next button. */\n    _nextClicked(): void {\n        this._activeDate = (this.currentView === 'month')\n            ? this._adapter.addCalendarMonths(this._activeDate, 1)\n            : this._adapter.addCalendarYears(this._activeDate, this.currentView === 'year' ? 1 : yearsPerPage);\n    }\n\n    /** Whether the previous period button is enabled. */\n    _previousEnabled(): boolean {\n        if (!this.minDate) {\n            return true;\n        }\n        return !this.minDate || !this._isSameView(this._activeDate, this.minDate);\n    }\n\n    /** Whether the next period button is enabled. */\n    _nextEnabled(): boolean {\n        return !this.maxDate || !this._isSameView(this._activeDate, this.maxDate);\n    }\n\n    /** Handles keydown events on the calendar body. */\n    _handleCalendarBodyKeydown(event: KeyboardEvent): void {\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n        if (this.currentView === 'month') {\n            this._handleCalendarBodyKeydownInMonthView(event);\n        } else if (this.currentView === 'year') {\n            this._handleCalendarBodyKeydownInYearView(event);\n        } else if (this.currentView === 'multi-year') {\n            this._handleCalendarBodyKeydownInMultiYearView(event);\n        } else {\n            this._handleCalendarBodyKeydownInClockView(event);\n        }\n    }\n\n    _focusActiveCell() {\n        this._ngZone.runOutsideAngular(() => {\n            this._ngZone.onStable\n                .asObservable()\n                .pipe(first())\n                .subscribe(() => this._elementRef.nativeElement.focus());\n        });\n    }\n\n    _calendarStateDone() {\n        this._calendarState = '';\n    }\n\n    /** Whether the two dates represent the same view in the current view mode (month or year). */\n    private _isSameView(date1: D, date2: D): boolean {\n        if (this.currentView === 'month') {\n            return (\n                this._adapter.getYear(date1) === this._adapter.getYear(date2) &&\n                this._adapter.getMonth(date1) === this._adapter.getMonth(date2)\n            );\n        }\n        if (this.currentView === 'year') {\n            return this._adapter.getYear(date1) === this._adapter.getYear(date2);\n        }\n        // Otherwise we are in 'multi-year' view.\n        return isSameMultiYearView(this._adapter, date1, date2, this.minDate, this.maxDate);\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in month view. */\n    private _handleCalendarBodyKeydownInMonthView(event: KeyboardEvent): void {\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this._activeDate = this._adapter.addCalendarDays(this._activeDate, -1);\n                break;\n            case RIGHT_ARROW:\n                this._activeDate = this._adapter.addCalendarDays(this._activeDate, 1);\n                break;\n            case UP_ARROW:\n                this._activeDate = this._adapter.addCalendarDays(this._activeDate, -7);\n                break;\n            case DOWN_ARROW:\n                this._activeDate = this._adapter.addCalendarDays(this._activeDate, 7);\n                break;\n            case HOME:\n                this._activeDate = this._adapter.addCalendarDays(this._activeDate, 1 - this._adapter.getDate(this._activeDate));\n                break;\n            case END:\n                this._activeDate = this._adapter.addCalendarDays(this._activeDate, this._adapter.getNumDaysInMonth(this._activeDate) - this._adapter.getDate(this._activeDate));\n                break;\n            case PAGE_UP:\n                this._activeDate = event.altKey\n                    ? this._adapter.addCalendarYears(this._activeDate, -1)\n                    : this._adapter.addCalendarMonths(this._activeDate, -1);\n                break;\n            case PAGE_DOWN:\n                this._activeDate = event.altKey\n                    ? this._adapter.addCalendarYears(this._activeDate, 1)\n                    : this._adapter.addCalendarMonths(this._activeDate, 1);\n                break;\n            case ENTER:\n                if (this._dateFilterForViews(this._activeDate)) {\n                    this._dateSelected(this._activeDate);\n                    // Prevent unexpected default actions such as form submission.\n                    event.preventDefault();\n                }\n                return;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in year view. */\n    private _handleCalendarBodyKeydownInYearView(event: KeyboardEvent): void {\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, -1);\n                break;\n            case RIGHT_ARROW:\n                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, 1);\n                break;\n            case UP_ARROW:\n                this._activeDate = this._prevMonthInSameCol(this._activeDate);\n                break;\n            case DOWN_ARROW:\n                this._activeDate = this._nextMonthInSameCol(this._activeDate);\n                break;\n            case HOME:\n                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, -this._adapter.getMonth(this._activeDate));\n                break;\n            case END:\n                this._activeDate = this._adapter.addCalendarMonths(this._activeDate, 11 - this._adapter.getMonth(this._activeDate));\n                break;\n            case PAGE_UP:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? -10 : -1);\n                break;\n            case PAGE_DOWN:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? 10 : 1);\n                break;\n            case ENTER:\n                this._monthSelected(this._activeDate);\n                break;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in multi-year view. */\n    private _handleCalendarBodyKeydownInMultiYearView(event: KeyboardEvent): void {\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, -1);\n                break;\n            case RIGHT_ARROW:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, 1);\n                break;\n            case UP_ARROW:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, -yearsPerRow);\n                break;\n            case DOWN_ARROW:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, yearsPerRow);\n                break;\n            case HOME:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, -getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate));\n                break;\n            case END:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, yearsPerPage - getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate) - 1);\n                break;\n            case PAGE_UP:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);\n                break;\n            case PAGE_DOWN:\n                this._activeDate = this._adapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);\n                break;\n            case ENTER:\n                this._yearSelected(this._activeDate);\n                break;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in month view. */\n    private _handleCalendarBodyKeydownInClockView(event: KeyboardEvent): void {\n        switch (event.keyCode) {\n            case UP_ARROW:\n                this._activeDate = this._clockView === 'hour'\n                    ? this._adapter.addCalendarHours(this._activeDate, 1)\n                    : this._adapter.addCalendarMinutes(this._activeDate, 1);\n                break;\n            case DOWN_ARROW:\n                this._activeDate = this._clockView === 'hour'\n                    ? this._adapter.addCalendarHours(this._activeDate, -1)\n                    : this._adapter.addCalendarMinutes(this._activeDate, -1);\n                break;\n            case ENTER:\n                this._timeSelected(this._activeDate);\n                return;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n\n    /**\n     * Determine the date for the month that comes before the given month in the same column in the\n     * calendar table.\n     */\n    private _prevMonthInSameCol(date: D): D {\n        // Determine how many months to jump forward given that there are 2 empty slots at the beginning of each year.\n        const increment = this._adapter.getMonth(date) <= 4 ? -5 : this._adapter.getMonth(date) >= 7 ? -7 : -12;\n        return this._adapter.addCalendarMonths(date, increment);\n    }\n\n    /**\n     * Determine the date for the month that comes after the given month in the same column in the\n     * calendar table.\n     */\n    private _nextMonthInSameCol(date: D): D {\n        // Determine how many months to jump forward given that there are 2 empty slots at the beginning of each year.\n        const increment = this._adapter.getMonth(date) <= 4 ? 7 : this._adapter.getMonth(date) >= 7 ? 5 : 12;\n        return this._adapter.addCalendarMonths(date, increment);\n    }\n\n    private calendarState(direction: string): void {\n        this._calendarState = direction;\n    }\n\n    private _2digit(n: number) {\n        return ('00' + n).slice(-2);\n    }\n\n}\n"]}