@gipisistemas/ng-core 1.1.10 → 1.1.12

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

@@ -0,0 +1,747 @@
+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
+ */
+var GIPIDatetimepickerCalendarComponent = /** @class */ (function () {
+    function GIPIDatetimepickerCalendarComponent(_elementRef, _intl, _ngZone, _adapter, _dateFormats, changeDetectorRef) {
+        var _this = this;
+        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 = function (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(function () { return changeDetectorRef.markForCheck(); });
+    }
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "type", {
+        get: function () {
+            return this._type;
+        },
+        set: function (value) {
+            this._type = value || 'date';
+            if (this.type === 'year') {
+                this.multiYearSelector = true;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "startAt", {
+        get: function () {
+            return this._startAt;
+        },
+        set: function (value) {
+            this._startAt = this._adapter.getValidDateOrNull(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "selected", {
+        get: function () {
+            return this._selected;
+        },
+        set: function (value) {
+            this._selected = this._adapter.getValidDateOrNull(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "minDate", {
+        get: function () {
+            return this._minDate;
+        },
+        set: function (value) {
+            this._minDate = this._adapter.getValidDateOrNull(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "maxDate", {
+        get: function () {
+            return this._maxDate;
+        },
+        set: function (value) {
+            this._maxDate = this._adapter.getValidDateOrNull(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_activeDate", {
+        /** The current active date. This determines which time period is shown and which date is highlighted when using keyboard navigation. */
+        get: function () {
+            return this._clampedActiveDate;
+        },
+        set: function (value) {
+            var 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');
+                }
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "currentView", {
+        get: function () {
+            return this._currentView;
+        },
+        set: function (view) {
+            this._currentView = view;
+            this.viewChanged.emit(view);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_yearLabel", {
+        /** The label for the current calendar view. */
+        get: function () {
+            return this._adapter.getYearName(this._activeDate);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_monthYearLabel", {
+        get: function () {
+            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.
+                var activeYear = this._adapter.getYear(this._activeDate);
+                var minYearOfPage = activeYear - getActiveOffset(this._adapter, this._activeDate, this.minDate, this.maxDate);
+                var maxYearOfPage = minYearOfPage + yearsPerPage - 1;
+                var minYearName = this._adapter.getYearName(this._adapter.createDate(minYearOfPage, 0, 1));
+                var 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);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_dateLabel", {
+        get: function () {
+            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);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "periodButtonLabel", {
+        get: function () {
+            return this.currentView == 'month' ? this._intl.switchToMultiYearViewLabel : this._intl.switchToMonthViewLabel;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "prevButtonLabel", {
+        /** The label for the previous button. */
+        get: function () {
+            return {
+                'month': this._intl.prevMonthLabel,
+                'year': this._intl.prevYearLabel,
+                'multi-year': this._intl.prevMultiYearLabel
+            }[this.currentView];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "nextButtonLabel", {
+        /** The label for the next button. */
+        get: function () {
+            return {
+                'month': this._intl.nextMonthLabel,
+                'year': this._intl.nextYearLabel,
+                'multi-year': this._intl.nextMultiYearLabel
+            }[this.currentView];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_hoursLabel", {
+        get: function () {
+            var hour = this._adapter.getHour(this._activeDate);
+            if (!!this.twelvehour) {
+                if (hour === 0) {
+                    hour = 24;
+                }
+                hour = hour > 12 ? hour - 12 : hour;
+            }
+            return this._2digit(hour);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_minutesLabel", {
+        get: function () {
+            return this._2digit(this._adapter.getMinute(this._activeDate));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_ariaLabelNext", {
+        get: function () {
+            switch (this._currentView) {
+                case 'month': return this.ariaNextMonthLabel;
+                case 'year': return this.ariaNextYearLabel;
+                case 'multi-year': return this.ariaNextMultiYearLabel;
+                default: return '';
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerCalendarComponent.prototype, "_ariaLabelPrev", {
+        get: function () {
+            switch (this._currentView) {
+                case 'month': return this.ariaPrevMonthLabel;
+                case 'year': return this.ariaPrevYearLabel;
+                case 'multi-year': return this.ariaPrevMultiYearLabel;
+                default: return '';
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIDatetimepickerCalendarComponent.prototype.ngAfterContentInit = function () {
+        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';
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype.ngOnDestroy = function () {
+        this._intlChanges.unsubscribe();
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._userSelected = function () {
+        this._userSelection.emit();
+    };
+    /** Handles date selection in the month view. */
+    GIPIDatetimepickerCalendarComponent.prototype._dateSelected = function (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. */
+    GIPIDatetimepickerCalendarComponent.prototype._monthSelected = function (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. */
+    GIPIDatetimepickerCalendarComponent.prototype._yearSelected = function (year) {
+        if (this.type === 'year') {
+            if (!this._adapter.sameYear(year, this.selected) ||
+                !this.preventSameDateTimeSelection) {
+                var normalizedDate = this._adapter.createDatetime(this._adapter.getYear(year), 0, 1, 0, 0);
+                this.selectedChange.emit(normalizedDate);
+            }
+        }
+        else {
+            this._activeDate = year;
+            this.currentView = 'year';
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._timeSelected = function (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);
+            }
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._onActiveDateChange = function (date) {
+        this._activeDate = date;
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._updateDate = function (date) {
+        if (!!this.twelvehour) {
+            var 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;
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._selectAMPM = function (date) {
+        if (this._adapter.getHour(date) > 11) {
+            this._AMPM = 'PM';
+        }
+        else {
+            this._AMPM = 'AM';
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._ampmClicked = function (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);
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._yearClicked = function () {
+        if (this.type === 'year' || this.multiYearSelector) {
+            this.currentView = 'multi-year';
+            return;
+        }
+        this.currentView = 'year';
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._dateClicked = function () {
+        if (this.type !== 'month') {
+            this.currentView = 'month';
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._hoursClicked = function () {
+        this.currentView = 'clock';
+        this._clockView = 'hour';
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._minutesClicked = function () {
+        this.currentView = 'clock';
+        this._clockView = 'minute';
+    };
+    /** Handles user clicks on the previous button. */
+    GIPIDatetimepickerCalendarComponent.prototype._previousClicked = function () {
+        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. */
+    GIPIDatetimepickerCalendarComponent.prototype._nextClicked = function () {
+        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. */
+    GIPIDatetimepickerCalendarComponent.prototype._previousEnabled = function () {
+        if (!this.minDate) {
+            return true;
+        }
+        return !this.minDate || !this._isSameView(this._activeDate, this.minDate);
+    };
+    /** Whether the next period button is enabled. */
+    GIPIDatetimepickerCalendarComponent.prototype._nextEnabled = function () {
+        return !this.maxDate || !this._isSameView(this._activeDate, this.maxDate);
+    };
+    /** Handles keydown events on the calendar body. */
+    GIPIDatetimepickerCalendarComponent.prototype._handleCalendarBodyKeydown = function (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);
+        }
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._focusActiveCell = function () {
+        var _this = this;
+        this._ngZone.runOutsideAngular(function () {
+            _this._ngZone.onStable
+                .asObservable()
+                .pipe(first())
+                .subscribe(function () { return _this._elementRef.nativeElement.focus(); });
+        });
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._calendarStateDone = function () {
+        this._calendarState = '';
+    };
+    /** Whether the two dates represent the same view in the current view mode (month or year). */
+    GIPIDatetimepickerCalendarComponent.prototype._isSameView = function (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. */
+    GIPIDatetimepickerCalendarComponent.prototype._handleCalendarBodyKeydownInMonthView = function (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. */
+    GIPIDatetimepickerCalendarComponent.prototype._handleCalendarBodyKeydownInYearView = function (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. */
+    GIPIDatetimepickerCalendarComponent.prototype._handleCalendarBodyKeydownInMultiYearView = function (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. */
+    GIPIDatetimepickerCalendarComponent.prototype._handleCalendarBodyKeydownInClockView = function (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.
+     */
+    GIPIDatetimepickerCalendarComponent.prototype._prevMonthInSameCol = function (date) {
+        // Determine how many months to jump forward given that there are 2 empty slots at the beginning of each year.
+        var 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.
+     */
+    GIPIDatetimepickerCalendarComponent.prototype._nextMonthInSameCol = function (date) {
+        // Determine how many months to jump forward given that there are 2 empty slots at the beginning of each year.
+        var increment = this._adapter.getMonth(date) <= 4 ? 7 : this._adapter.getMonth(date) >= 7 ? 5 : 12;
+        return this._adapter.addCalendarMonths(date, increment);
+    };
+    GIPIDatetimepickerCalendarComponent.prototype.calendarState = function (direction) {
+        this._calendarState = direction;
+    };
+    GIPIDatetimepickerCalendarComponent.prototype._2digit = function (n) {
+        return ('00' + n).slice(-2);
+    };
+    GIPIDatetimepickerCalendarComponent.ctorParameters = function () { return [
+        { 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);
+    return 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"]}