/** * @license * Copyright Google LLC All Rights Reserved. * * Use of this source code is governed by an MIT-style license that can be * found in the LICENSE file at https://angular.io/license */ import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, UP_ARROW, SPACE, } from '@angular/cdk/keycodes'; import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/core'; import { DateAdapter } from '@angular/material/core'; import { Directionality } from '@angular/cdk/bidi'; import { MatCalendarBody, MatCalendarCell, } from './calendar-body'; import { createMissingDateImplError } from './datepicker-errors'; import { Subscription } from 'rxjs'; import { startWith } from 'rxjs/operators'; import { DateRange } from './date-selection-model'; import * as ɵngcc0 from '@angular/core'; import * as ɵngcc1 from '@angular/material/core'; import * as ɵngcc2 from '@angular/cdk/bidi'; import * as ɵngcc3 from './calendar-body'; export const yearsPerPage = 24; export const yearsPerRow = 4; /** * An internal component used to display a year selector in the datepicker. * @docs-private */ export class MatMultiYearView { constructor(_changeDetectorRef, _dateAdapter, _dir) { this._changeDetectorRef = _changeDetectorRef; this._dateAdapter = _dateAdapter; this._dir = _dir; this._rerenderSubscription = Subscription.EMPTY; /** Emits when a new year is selected. */ this.selectedChange = new EventEmitter(); /** Emits the selected year. This doesn't imply a change on the selected date */ this.yearSelected = new EventEmitter(); /** Emits when any date is activated. */ this.activeDateChange = new EventEmitter(); if (!this._dateAdapter && (typeof ngDevMode === 'undefined' || ngDevMode)) { throw createMissingDateImplError('DateAdapter'); } this._activeDate = this._dateAdapter.today(); } /** The date to display in this multi-year view (everything other than the year is ignored). */ get activeDate() { return this._activeDate; } set activeDate(value) { let oldActiveDate = this._activeDate; const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today(); this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate); if (!isSameMultiYearView(this._dateAdapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) { this._init(); } } /** The currently selected date. */ get selected() { return this._selected; } set selected(value) { if (value instanceof DateRange) { this._selected = value; } else { this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)); } this._setSelectedYear(value); } /** The minimum selectable date. */ get minDate() { return this._minDate; } set minDate(value) { this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)); } /** The maximum selectable date. */ get maxDate() { return this._maxDate; } set maxDate(value) { this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)); } ngAfterContentInit() { this._rerenderSubscription = this._dateAdapter.localeChanges .pipe(startWith(null)) .subscribe(() => this._init()); } ngOnDestroy() { this._rerenderSubscription.unsubscribe(); } /** Initializes this multi-year view. */ _init() { this._todayYear = this._dateAdapter.getYear(this._dateAdapter.today()); // We want a range years such that we maximize the number of // enabled dates visible at once. This prevents issues where the minimum year // is the last item of a page OR the maximum year is the first item of a page. // The offset from the active year to the "slot" for the starting year is the // *actual* first rendered year in the multi-year view. const activeYear = this._dateAdapter.getYear(this._activeDate); const minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate); this._years = []; for (let i = 0, row = []; i < yearsPerPage; i++) { row.push(minYearOfPage + i); if (row.length == yearsPerRow) { this._years.push(row.map(year => this._createCellForYear(year))); row = []; } } this._changeDetectorRef.markForCheck(); } /** Handles when a new year is selected. */ _yearSelected(event) { const year = event.value; this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1)); let month = this._dateAdapter.getMonth(this.activeDate); let daysInMonth = this._dateAdapter.getNumDaysInMonth(this._dateAdapter.createDate(year, month, 1)); this.selectedChange.emit(this._dateAdapter.createDate(year, month, Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth))); } /** Handles keydown events on the calendar body when calendar is in multi-year view. */ _handleCalendarBodyKeydown(event) { const oldActiveDate = this._activeDate; const isRtl = this._isRtl(); switch (event.keyCode) { case LEFT_ARROW: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? 1 : -1); break; case RIGHT_ARROW: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? -1 : 1); break; case UP_ARROW: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -yearsPerRow); break; case DOWN_ARROW: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerRow); break; case HOME: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate)); break; case END: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerPage - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate) - 1); break; case PAGE_UP: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage); break; case PAGE_DOWN: this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage); break; case ENTER: case SPACE: // Note that we only prevent the default action here while the selection happens in // `keyup` below. We can't do the selection here, because it can cause the calendar to // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup` // because it's too late (see #23305). this._selectionKeyPressed = true; break; default: // Don't prevent default or focus active cell on keys that we don't explicitly handle. return; } if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) { this.activeDateChange.emit(this.activeDate); } this._focusActiveCell(); // Prevent unexpected default actions such as form submission. event.preventDefault(); } /** Handles keyup events on the calendar body when calendar is in multi-year view. */ _handleCalendarBodyKeyup(event) { if (event.keyCode === SPACE || event.keyCode === ENTER) { if (this._selectionKeyPressed) { this._yearSelected({ value: this._dateAdapter.getYear(this._activeDate), event }); } this._selectionKeyPressed = false; } } _getActiveCell() { return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate); } /** Focuses the active cell after the microtask queue is empty. */ _focusActiveCell() { this._matCalendarBody._focusActiveCell(); } /** Creates an MatCalendarCell for the given year. */ _createCellForYear(year) { const date = this._dateAdapter.createDate(year, 0, 1); const yearName = this._dateAdapter.getYearName(date); const cellClasses = this.dateClass ? this.dateClass(date, 'multi-year') : undefined; return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year), cellClasses); } /** Whether the given year is enabled. */ _shouldEnableYear(year) { // disable if the year is greater than maxDate lower than minDate if (year === undefined || year === null || (this.maxDate && year > this._dateAdapter.getYear(this.maxDate)) || (this.minDate && year < this._dateAdapter.getYear(this.minDate))) { return false; } // enable if it reaches here and there's no filter defined if (!this.dateFilter) { return true; } const firstOfYear = this._dateAdapter.createDate(year, 0, 1); // If any date in the year is enabled count the year as enabled. for (let date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) { if (this.dateFilter(date)) { return true; } } return false; } /** Determines whether the user has the RTL layout direction. */ _isRtl() { return this._dir && this._dir.value === 'rtl'; } /** Sets the currently-highlighted year based on a model value. */ _setSelectedYear(value) { this._selectedYear = null; if (value instanceof DateRange) { const displayValue = value.start || value.end; if (displayValue) { this._selectedYear = this._dateAdapter.getYear(displayValue); } } else if (value) { this._selectedYear = this._dateAdapter.getYear(value); } } } MatMultiYearView.ɵfac = function MatMultiYearView_Factory(t) { return new (t || MatMultiYearView)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.DateAdapter, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.Directionality, 8)); }; MatMultiYearView.ɵcmp = /*@__PURE__*/ ɵngcc0.ɵɵdefineComponent({ type: MatMultiYearView, selectors: [["mat-multi-year-view"]], viewQuery: function MatMultiYearView_Query(rf, ctx) { if (rf & 1) { ɵngcc0.ɵɵviewQuery(MatCalendarBody, 5); } if (rf & 2) { let _t; ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._matCalendarBody = _t.first); } }, inputs: { activeDate: "activeDate", selected: "selected", minDate: "minDate", maxDate: "maxDate", dateFilter: "dateFilter", dateClass: "dateClass" }, outputs: { selectedChange: "selectedChange", yearSelected: "yearSelected", activeDateChange: "activeDateChange" }, exportAs: ["matMultiYearView"], decls: 5, vars: 7, consts: [["role", "grid", 1, "mat-calendar-table"], ["aria-hidden", "true", 1, "mat-calendar-table-header"], ["colspan", "4", 1, "mat-calendar-table-header-divider"], ["mat-calendar-body", "", 3, "rows", "todayValue", "startValue", "endValue", "numCols", "cellAspectRatio", "activeCell", "selectedValueChange", "keyup", "keydown"]], template: function MatMultiYearView_Template(rf, ctx) { if (rf & 1) { ɵngcc0.ɵɵelementStart(0, "table", 0); ɵngcc0.ɵɵelementStart(1, "thead", 1); ɵngcc0.ɵɵelementStart(2, "tr"); ɵngcc0.ɵɵelement(3, "th", 2); ɵngcc0.ɵɵelementEnd(); ɵngcc0.ɵɵelementEnd(); ɵngcc0.ɵɵelementStart(4, "tbody", 3); ɵngcc0.ɵɵlistener("selectedValueChange", function MatMultiYearView_Template_tbody_selectedValueChange_4_listener($event) { return ctx._yearSelected($event); })("keyup", function MatMultiYearView_Template_tbody_keyup_4_listener($event) { return ctx._handleCalendarBodyKeyup($event); })("keydown", function MatMultiYearView_Template_tbody_keydown_4_listener($event) { return ctx._handleCalendarBodyKeydown($event); }); ɵngcc0.ɵɵelementEnd(); ɵngcc0.ɵɵelementEnd(); } if (rf & 2) { ɵngcc0.ɵɵadvance(4); ɵngcc0.ɵɵproperty("rows", ctx._years)("todayValue", ctx._todayYear)("startValue", ctx._selectedYear)("endValue", ctx._selectedYear)("numCols", 4)("cellAspectRatio", 4 / 7)("activeCell", ctx._getActiveCell()); } }, directives: [ɵngcc3.MatCalendarBody], encapsulation: 2, changeDetection: 0 }); MatMultiYearView.ctorParameters = () => [ { type: ChangeDetectorRef }, { type: DateAdapter, decorators: [{ type: Optional }] }, { type: Directionality, decorators: [{ type: Optional }] } ]; MatMultiYearView.propDecorators = { activeDate: [{ type: Input }], selected: [{ type: Input }], minDate: [{ type: Input }], maxDate: [{ type: Input }], dateFilter: [{ type: Input }], dateClass: [{ type: Input }], selectedChange: [{ type: Output }], yearSelected: [{ type: Output }], activeDateChange: [{ type: Output }], _matCalendarBody: [{ type: ViewChild, args: [MatCalendarBody,] }] }; (function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatMultiYearView, [{ type: Component, args: [{ selector: 'mat-multi-year-view', template: "\n \n \n \n \n \n
\n", exportAs: 'matMultiYearView', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush }] }], function () { return [{ type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc1.DateAdapter, decorators: [{ type: Optional }] }, { type: ɵngcc2.Directionality, decorators: [{ type: Optional }] }]; }, { selectedChange: [{ type: Output }], yearSelected: [{ type: Output }], activeDateChange: [{ type: Output }], activeDate: [{ type: Input }], selected: [{ type: Input }], minDate: [{ type: Input }], maxDate: [{ type: Input }], dateFilter: [{ type: Input }], dateClass: [{ type: Input }], _matCalendarBody: [{ type: ViewChild, args: [MatCalendarBody] }] }); })(); export function isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) { const year1 = dateAdapter.getYear(date1); const year2 = dateAdapter.getYear(date2); const startingYear = getStartingYear(dateAdapter, minDate, maxDate); return Math.floor((year1 - startingYear) / yearsPerPage) === Math.floor((year2 - startingYear) / yearsPerPage); } /** * When the multi-year view is first opened, the active year will be in view. * So we compute how many years are between the active year and the *slot* where our * "startingYear" will render when paged into view. */ export function getActiveOffset(dateAdapter, activeDate, minDate, maxDate) { const activeYear = dateAdapter.getYear(activeDate); return euclideanModulo((activeYear - getStartingYear(dateAdapter, minDate, maxDate)), yearsPerPage); } /** * We pick a "starting" year such that either the maximum year would be at the end * or the minimum year would be at the beginning of a page. */ function getStartingYear(dateAdapter, minDate, maxDate) { let startingYear = 0; if (maxDate) { const maxYear = dateAdapter.getYear(maxDate); startingYear = maxYear - yearsPerPage + 1; } else if (minDate) { startingYear = dateAdapter.getYear(minDate); } return startingYear; } /** Gets remainder that is non-negative, even if first number is negative */ function euclideanModulo(a, b) { return (a % b + b) % b; } //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"multi-year-view.js","sources":["../../../../../../src/material/datepicker/multi-year-view.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AAEH,OAAO,EACL,UAAU,EACV,GAAG,EACH,KAAK,EACL,IAAI,EACJ,UAAU,EACV,SAAS,EACT,OAAO,EACP,WAAW,EACX,QAAQ,EACR,KAAK,GACN,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,MAAM,EACN,SAAS,EACT,iBAAiB,GAElB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,WAAW,EAAC,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACL,eAAe,EACf,eAAe,GAGhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,0BAA0B,EAAC,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAC,YAAY,EAAC,MAAM,MAAM,CAAC;AAClC,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAC,SAAS,EAAC,MAAM,wBAAwB,CAAC;;;;;AAEjD,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC;AAE/B,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAE7B;AACA;AACA;AACA,GAAG;AAQH,MAAM,OAAO,gBAAgB;AAAG,IAkF9B,YAAoB,kBAAqC,EAC1B,YAA4B,EAC3B,IAAqB;AACvD,QAHsB,uBAAkB,GAAlB,kBAAkB,CAAmB;AAAC,QAC3B,iBAAY,GAAZ,YAAY,CAAgB;AAAC,QAC5B,SAAI,GAAJ,IAAI,CAAiB;AAAC,QAnF9C,0BAAqB,GAAG,YAAY,CAAC,KAAK,CAAC;AACrD,QA2DE,yCAAyC;AAC3C,QAAqB,mBAAc,GAAoB,IAAI,YAAY,EAAK,CAAC;AAC7E,QACE,gFAAgF;AAClF,QAAqB,iBAAY,GAAoB,IAAI,YAAY,EAAK,CAAC;AAC3E,QACE,wCAAwC;AAC1C,QAAqB,qBAAgB,GAAoB,IAAI,YAAY,EAAK,CAAC;AAC/E,QAgBI,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,EAAE;AAC/E,YAAM,MAAM,0BAA0B,CAAC,aAAa,CAAC,CAAC;AACtD,SAAK;AACL,QACI,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;AACjD,IAAE,CAAC;AACH,IArFE,+FAA+F;AACjG,IAAE,IACI,UAAU,KAAQ,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;AAClD,IAAE,IAAI,UAAU,CAAC,KAAQ;AACzB,QAAI,IAAI,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC;AACzC,QAAI,MAAM,SAAS,GACb,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAClC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CACrC,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;AACrC,QAAI,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;AAC1F,QACI,IAAI,CAAC,mBAAmB,CACtB,IAAI,CAAC,YAAY,EAAE,aAAa,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE;AACvF,YAAM,IAAI,CAAC,KAAK,EAAE,CAAC;AACnB,SAAK;AACL,IAAE,CAAC;AACH,IAEE,mCAAmC;AACrC,IAAE,IACI,QAAQ,KAA8B,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;AACpE,IAAE,IAAI,QAAQ,CAAC,KAA8B;AAC7C,QAAI,IAAI,KAAK,YAAY,SAAS,EAAE;AACpC,YAAM,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;AAC7B,SAAK;AAAC,aAAK;AACX,YAAM,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;AAClG,SAAK;AACL,QACI,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;AACjC,IAAE,CAAC;AACH,IAGE,mCAAmC;AACrC,IAAE,IACI,OAAO,KAAe,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AACnD,IAAE,IAAI,OAAO,CAAC,KAAe;AAC7B,QAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/F,IAAE,CAAC;AACH,IAEE,mCAAmC;AACrC,IAAE,IACI,OAAO,KAAe,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AACnD,IAAE,IAAI,OAAO,CAAC,KAAe;AAC7B,QAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;AAC/F,IAAE,CAAC;AACH,IAuCE,kBAAkB;AACpB,QAAI,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa;AAChE,aAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AAC5B,aAAO,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;AACrC,IAAE,CAAC;AACH,IACE,WAAW;AACb,QAAI,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;AAC7C,IAAE,CAAC;AACH,IACE,wCAAwC;AAC1C,IAAE,KAAK;AACP,QAAI,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC;AAC3E,QACI,4DAA4D;AAChE,QAAI,6EAA6E;AACjF,QAAI,8EAA8E;AAClF,QACI,6EAA6E;AACjF,QAAI,uDAAuD;AAC3D,QAAI,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;AACnE,QAAI,MAAM,aAAa,GAAG,UAAU,GAAG,eAAe,CAChD,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;AACtE,QACI,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;AACrB,QAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAa,EAAE,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE;AAC/D,YAAM,GAAG,CAAC,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;AAClC,YAAM,IAAI,GAAG,CAAC,MAAM,IAAI,WAAW,EAAE;AACrC,gBAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACzE,gBAAQ,GAAG,GAAG,EAAE,CAAC;AACjB,aAAO;AACP,SAAK;AACL,QAAI,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;AAC3C,IAAE,CAAC;AACH,IACE,2CAA2C;AAC7C,IAAE,aAAa,CAAC,KAAmC;AACnD,QAAI,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;AAC7B,QAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACrE,QAAI,IAAI,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAC5D,QAAI,IAAI,WAAW,GACX,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;AAC1F,QAAI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAC7D,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;AAC5E,IAAE,CAAC;AACH,IACE,uFAAuF;AACzF,IAAE,0BAA0B,CAAC,KAAoB;AAAI,QACjD,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC;AAC3C,QAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;AAChC,QACI,QAAQ,KAAK,CAAC,OAAO,EAAE;AAC3B,YAAM,KAAK,UAAU;AACrB,gBAAQ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/F,gBAAQ,MAAM;AACd,YAAM,KAAK,WAAW;AACtB,gBAAQ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/F,gBAAQ,MAAM;AACd,YAAM,KAAK,QAAQ;AACnB,gBAAQ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,WAAW,CAAC,CAAC;AAC7F,gBAAQ,MAAM;AACd,YAAM,KAAK,UAAU;AACrB,gBAAQ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AAC5F,gBAAQ,MAAM;AACd,YAAM,KAAK,IAAI;AACf,gBAAQ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EACnE,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAC5F,gBAAQ,MAAM;AACd,YAAM,KAAK,GAAG;AACd,gBAAQ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EACnE,YAAY,GAAG,eAAe,CAC5B,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AACjF,gBAAQ,MAAM;AACd,YAAM,KAAK,OAAO;AAClB,gBAAQ,IAAI,CAAC,UAAU;AACvB,oBAAY,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAC9B,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AACrF,gBAAQ,MAAM;AACd,YAAM,KAAK,SAAS;AACpB,gBAAQ,IAAI,CAAC,UAAU;AACvB,oBAAY,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAC9B,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,GAAG,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AACnF,gBAAQ,MAAM;AACd,YAAM,KAAK,KAAK,CAAC;AACjB,YAAM,KAAK,KAAK;AAChB,gBAAQ,mFAAmF;AAC3F,gBAAQ,sFAAsF;AAC9F,gBAAQ,0FAA0F;AAClG,gBAAQ,sCAAsC;AAC9C,gBAAQ,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;AACzC,gBAAQ,MAAM;AACd,YAAM;AACN,gBAAQ,sFAAsF;AAC9F,gBAAQ,OAAO;AACf,SAAK;AACL,QAAI,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;AACvE,YAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAClD,SAAK;AACL,QACI,IAAI,CAAC,gBAAgB,EAAE,CAAC;AAC5B,QAAI,8DAA8D;AAClE,QAAI,KAAK,CAAC,cAAc,EAAE,CAAC;AAC3B,IAAE,CAAC;AACH,IACE,qFAAqF;AACvF,IAAE,wBAAwB,CAAC,KAAoB;AAAI,QAC/C,IAAI,KAAK,CAAC,OAAO,KAAK,KAAK,IAAI,KAAK,CAAC,OAAO,KAAK,KAAK,EAAE;AAC5D,YAAM,IAAI,IAAI,CAAC,oBAAoB,EAAE;AACrC,gBAAQ,IAAI,CAAC,aAAa,CAAC,EAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,KAAK,EAAC,CAAC,CAAC;AACxF,aAAO;AACP,YACM,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;AACxC,SAAK;AACL,IAAE,CAAC;AACH,IACE,cAAc;AAAK,QACjB,OAAO,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3F,IAAE,CAAC;AACH,IACE,kEAAkE;AACpE,IAAE,gBAAgB;AAClB,QAAI,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,CAAC;AAC7C,IAAE,CAAC;AACH,IACE,qDAAqD;AACvD,IAAU,kBAAkB,CAAC,IAAY;AACzC,QAAI,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1D,QAAI,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AACzD,QAAI,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACxF,QACI,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC;AACpG,IAAE,CAAC;AACH,IACE,yCAAyC;AAC3C,IAAU,iBAAiB,CAAC,IAAY;AACxC,QAAI,iEAAiE;AACrE,QAAI,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI;AAC3C,YAAQ,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACxE,YAAQ,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE;AAC1E,YAAM,OAAO,KAAK,CAAC;AACnB,SAAK;AACL,QACI,0DAA0D;AAC9D,QAAI,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;AAC1B,YAAM,OAAO,IAAI,CAAC;AAClB,SAAK;AACL,QACI,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACjE,QACI,gEAAgE;AACpE,QAAI,KAAK,IAAI,IAAI,GAAG,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,EAClE,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;AACzD,YAAM,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;AACjC,gBAAQ,OAAO,IAAI,CAAC;AACpB,aAAO;AACP,SAAK;AACL,QACI,OAAO,KAAK,CAAC;AACjB,IAAE,CAAC;AACH,IACE,gEAAgE;AAClE,IAAU,MAAM;AAChB,QAAI,OAAO,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC;AAClD,IAAE,CAAC;AACH,IACE,kEAAkE;AACpE,IAAU,gBAAgB,CAAC,KAA8B;AACzD,QAAI,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;AAC9B,QACI,IAAI,KAAK,YAAY,SAAS,EAAE;AACpC,YAAM,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC;AACpD,YACM,IAAI,YAAY,EAAE;AACxB,gBAAQ,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;AACrE,aAAO;AACP,SAAK;AAAC,aAAK,IAAI,KAAK,EAAE;AACtB,YAAM,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC5D,SAAK;AACL,IAAE,CAAC;AACH;4CAtRC,SAAS,SAAC,kBACT,QAAQ,EAAE,qBAAqB,kBAC/B;;;;;;6MAAmC,kBACnC,QAAQ,EAAE,kBAAkB,kBAC5B,aAAa,EAAE,iBAAiB,CAAC,IAAI,kBACrC,eAAe,EAAE,uBAAuB,CAAC,MAAM,cAChD;;;;;;;;;;;;;;uFACI;AAAC;AAA0C,YAtC9C,iBAAiB;AACjB,YASM,WAAW,uBA+GJ,QAAQ;AAAO,YA9GtB,cAAc,uBA+GP,QAAQ;AAAM;AAAG;AACvB,yBA9EN,KAAK;AACN,uBAiBC,KAAK;AACN,sBAcC,KAAK;AACN,sBAOC,KAAK;AACN,yBAOC,KAAK;AAAK,wBAGV,KAAK;AAAK,6BAGV,MAAM;AAAK,2BAGX,MAAM;AAAK,+BAGX,MAAM;AAAK,+BAGX,SAAS,SAAC,eAAe;AAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAE;AA0MpC,MAAM,UAAU,mBAAmB,CACjC,WAA2B,EAAE,KAAQ,EAAE,KAAQ,EAAE,OAAiB,EAAE,OAAiB;AAAI,IACzF,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC3C,IAAE,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC3C,IAAE,MAAM,YAAY,GAAG,eAAe,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AACtE,IAAE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC;AAC1D,QAAU,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,CAAC;AAC5D,CAAC;AAED;AACA;AACA;AACA;AACA,GAAG;AACH,MAAM,UAAU,eAAe,CAC7B,WAA2B,EAAE,UAAa,EAAE,OAAiB,EAAE,OAAiB;AAAI,IACpF,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AACrD,IAAE,OAAO,eAAe,CAAC,CAAC,UAAU,GAAG,eAAe,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,EAClF,YAAY,CAAC,CAAC;AAClB,CAAC;AAED;AACA;AACA;AACA,GAAG;AACH,SAAS,eAAe,CACtB,WAA2B,EAAE,OAAiB,EAAE,OAAiB;AAAI,IACrE,IAAI,YAAY,GAAG,CAAC,CAAC;AACvB,IAAE,IAAI,OAAO,EAAE;AACf,QAAI,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACjD,QAAI,YAAY,GAAG,OAAO,GAAG,YAAY,GAAG,CAAC,CAAC;AAC9C,KAAG;AAAC,SAAK,IAAI,OAAO,EAAE;AACtB,QAAI,YAAY,GAAG,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AAChD,KAAG;AACH,IAAE,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,4EAA4E;AAC5E,SAAS,eAAe,CAAE,CAAS,EAAE,CAAS;AAAI,IAChD,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AACD","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  DOWN_ARROW,\n  END,\n  ENTER,\n  HOME,\n  LEFT_ARROW,\n  PAGE_DOWN,\n  PAGE_UP,\n  RIGHT_ARROW,\n  UP_ARROW,\n  SPACE,\n} from '@angular/cdk/keycodes';\nimport {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  Optional,\n  Output,\n  ViewChild,\n  ViewEncapsulation,\n  OnDestroy,\n} from '@angular/core';\nimport {DateAdapter} from '@angular/material/core';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {\n  MatCalendarBody,\n  MatCalendarCell,\n  MatCalendarUserEvent,\n  MatCalendarCellClassFunction,\n} from './calendar-body';\nimport {createMissingDateImplError} from './datepicker-errors';\nimport {Subscription} from 'rxjs';\nimport {startWith} from 'rxjs/operators';\nimport {DateRange} from './date-selection-model';\n\nexport const yearsPerPage = 24;\n\nexport const yearsPerRow = 4;\n\n/**\n * An internal component used to display a year selector in the datepicker.\n * @docs-private\n */\n@Component({\n  selector: 'mat-multi-year-view',\n  templateUrl: 'multi-year-view.html',\n  exportAs: 'matMultiYearView',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class MatMultiYearView<D> implements AfterContentInit, OnDestroy {\n  private _rerenderSubscription = Subscription.EMPTY;\n\n  /** Flag used to filter out space/enter keyup events that originated outside of the view. */\n  private _selectionKeyPressed: boolean;\n\n  /** The date to display in this multi-year view (everything other than the year is ignored). */\n  @Input()\n  get activeDate(): D { return this._activeDate; }\n  set activeDate(value: D) {\n    let oldActiveDate = this._activeDate;\n    const validDate =\n      this._dateAdapter.getValidDateOrNull(\n        this._dateAdapter.deserialize(value)\n      ) || this._dateAdapter.today();\n    this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);\n\n    if (!isSameMultiYearView(\n      this._dateAdapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {\n      this._init();\n    }\n  }\n  private _activeDate: D;\n\n  /** The currently selected date. */\n  @Input()\n  get selected(): DateRange<D> | D | null { return this._selected; }\n  set selected(value: DateRange<D> | D | null) {\n    if (value instanceof DateRange) {\n      this._selected = value;\n    } else {\n      this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n\n    this._setSelectedYear(value);\n  }\n  private _selected: DateRange<D> | D | null;\n\n\n  /** The minimum selectable date. */\n  @Input()\n  get minDate(): D | null { return this._minDate; }\n  set minDate(value: D | null) {\n    this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  private _minDate: D | null;\n\n  /** The maximum selectable date. */\n  @Input()\n  get maxDate(): D | null { return this._maxDate; }\n  set maxDate(value: D | null) {\n    this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n  }\n  private _maxDate: D | null;\n\n  /** A function used to filter which dates are selectable. */\n  @Input() dateFilter: (date: D) => boolean;\n\n  /** Function that can be used to add custom CSS classes to date cells. */\n  @Input() dateClass: MatCalendarCellClassFunction<D>;\n\n  /** Emits when a new year is selected. */\n  @Output() readonly selectedChange: EventEmitter<D> = new EventEmitter<D>();\n\n  /** Emits the selected year. This doesn't imply a change on the selected date */\n  @Output() readonly yearSelected: EventEmitter<D> = new EventEmitter<D>();\n\n  /** Emits when any date is activated. */\n  @Output() readonly activeDateChange: EventEmitter<D> = new EventEmitter<D>();\n\n  /** The body of calendar table */\n  @ViewChild(MatCalendarBody) _matCalendarBody: MatCalendarBody;\n\n  /** Grid of calendar cells representing the currently displayed years. */\n  _years: MatCalendarCell[][];\n\n  /** The year that today falls on. */\n  _todayYear: number;\n\n  /** The year of the selected date. Null if the selected date is null. */\n  _selectedYear: number | null;\n\n  constructor(private _changeDetectorRef: ChangeDetectorRef,\n              @Optional() public _dateAdapter: DateAdapter<D>,\n              @Optional() private _dir?: Directionality) {\n    if (!this._dateAdapter && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw createMissingDateImplError('DateAdapter');\n    }\n\n    this._activeDate = this._dateAdapter.today();\n  }\n\n  ngAfterContentInit() {\n    this._rerenderSubscription = this._dateAdapter.localeChanges\n      .pipe(startWith(null))\n      .subscribe(() => this._init());\n  }\n\n  ngOnDestroy() {\n    this._rerenderSubscription.unsubscribe();\n  }\n\n  /** Initializes this multi-year view. */\n  _init() {\n    this._todayYear = this._dateAdapter.getYear(this._dateAdapter.today());\n\n    // We want a range years such that we maximize the number of\n    // enabled dates visible at once. This prevents issues where the minimum year\n    // is the last item of a page OR the maximum year is the first item of a page.\n\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.\n    const activeYear = this._dateAdapter.getYear(this._activeDate);\n    const minYearOfPage = activeYear - getActiveOffset(\n      this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n\n    this._years = [];\n    for (let i = 0, row: number[] = []; i < yearsPerPage; i++) {\n      row.push(minYearOfPage + i);\n      if (row.length == yearsPerRow) {\n        this._years.push(row.map(year => this._createCellForYear(year)));\n        row = [];\n      }\n    }\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Handles when a new year is selected. */\n  _yearSelected(event: MatCalendarUserEvent<number>) {\n    const year = event.value;\n    this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1));\n    let month = this._dateAdapter.getMonth(this.activeDate);\n    let daysInMonth =\n        this._dateAdapter.getNumDaysInMonth(this._dateAdapter.createDate(year, month, 1));\n    this.selectedChange.emit(this._dateAdapter.createDate(year, month,\n        Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));\n  }\n\n  /** Handles keydown events on the calendar body when calendar is in multi-year view. */\n  _handleCalendarBodyKeydown(event: KeyboardEvent): void {\n    const oldActiveDate = this._activeDate;\n    const isRtl = this._isRtl();\n\n    switch (event.keyCode) {\n      case LEFT_ARROW:\n        this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? 1 : -1);\n        break;\n      case RIGHT_ARROW:\n        this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? -1 : 1);\n        break;\n      case UP_ARROW:\n        this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -yearsPerRow);\n        break;\n      case DOWN_ARROW:\n        this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerRow);\n        break;\n      case HOME:\n        this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate,\n          -getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate));\n        break;\n      case END:\n        this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate,\n          yearsPerPage - getActiveOffset(\n            this._dateAdapter, this.activeDate, this.minDate, this.maxDate) - 1);\n        break;\n      case PAGE_UP:\n        this.activeDate =\n            this._dateAdapter.addCalendarYears(\n                this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);\n        break;\n      case PAGE_DOWN:\n        this.activeDate =\n            this._dateAdapter.addCalendarYears(\n                this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);\n        break;\n      case ENTER:\n      case SPACE:\n        // Note that we only prevent the default action here while the selection happens in\n        // `keyup` below. We can't do the selection here, because it can cause the calendar to\n        // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`\n        // because it's too late (see #23305).\n        this._selectionKeyPressed = true;\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    if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {\n      this.activeDateChange.emit(this.activeDate);\n    }\n\n    this._focusActiveCell();\n    // Prevent unexpected default actions such as form submission.\n    event.preventDefault();\n  }\n\n  /** Handles keyup events on the calendar body when calendar is in multi-year view. */\n  _handleCalendarBodyKeyup(event: KeyboardEvent): void {\n    if (event.keyCode === SPACE || event.keyCode === ENTER) {\n      if (this._selectionKeyPressed) {\n        this._yearSelected({value: this._dateAdapter.getYear(this._activeDate), event});\n      }\n\n      this._selectionKeyPressed = false;\n    }\n  }\n\n  _getActiveCell(): number {\n    return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n  }\n\n  /** Focuses the active cell after the microtask queue is empty. */\n  _focusActiveCell() {\n    this._matCalendarBody._focusActiveCell();\n  }\n\n  /** Creates an MatCalendarCell for the given year. */\n  private _createCellForYear(year: number) {\n    const date = this._dateAdapter.createDate(year, 0, 1);\n    const yearName = this._dateAdapter.getYearName(date);\n    const cellClasses = this.dateClass ? this.dateClass(date, 'multi-year') : undefined;\n\n    return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year), cellClasses);\n  }\n\n  /** Whether the given year is enabled. */\n  private _shouldEnableYear(year: number) {\n    // disable if the year is greater than maxDate lower than minDate\n    if (year === undefined || year === null ||\n        (this.maxDate && year > this._dateAdapter.getYear(this.maxDate)) ||\n        (this.minDate && year < this._dateAdapter.getYear(this.minDate))) {\n      return false;\n    }\n\n    // enable if it reaches here and there's no filter defined\n    if (!this.dateFilter) {\n      return true;\n    }\n\n    const firstOfYear = this._dateAdapter.createDate(year, 0, 1);\n\n    // If any date in the year is enabled count the year as enabled.\n    for (let date = firstOfYear; this._dateAdapter.getYear(date) == year;\n      date = this._dateAdapter.addCalendarDays(date, 1)) {\n      if (this.dateFilter(date)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /** Determines whether the user has the RTL layout direction. */\n  private _isRtl() {\n    return this._dir && this._dir.value === 'rtl';\n  }\n\n  /** Sets the currently-highlighted year based on a model value. */\n  private _setSelectedYear(value: DateRange<D> | D | null) {\n    this._selectedYear = null;\n\n    if (value instanceof DateRange) {\n      const displayValue = value.start || value.end;\n\n      if (displayValue) {\n        this._selectedYear = this._dateAdapter.getYear(displayValue);\n      }\n    } else if (value) {\n      this._selectedYear = this._dateAdapter.getYear(value);\n    }\n  }\n}\n\nexport function isSameMultiYearView<D>(\n  dateAdapter: DateAdapter<D>, date1: D, date2: D, minDate: D | null, maxDate: D | null): boolean {\n  const year1 = dateAdapter.getYear(date1);\n  const year2 = dateAdapter.getYear(date2);\n  const startingYear = getStartingYear(dateAdapter, minDate, maxDate);\n  return Math.floor((year1 - startingYear) / yearsPerPage) ===\n          Math.floor((year2 - startingYear) / yearsPerPage);\n}\n\n/**\n * When the multi-year view is first opened, the active year will be in view.\n * So we compute how many years are between the active year and the *slot* where our\n * \"startingYear\" will render when paged into view.\n */\nexport function getActiveOffset<D>(\n  dateAdapter: DateAdapter<D>, activeDate: D, minDate: D | null, maxDate: D | null): number {\n  const activeYear = dateAdapter.getYear(activeDate);\n  return euclideanModulo((activeYear - getStartingYear(dateAdapter, minDate, maxDate)),\n    yearsPerPage);\n}\n\n/**\n * We pick a \"starting\" year such that either the maximum year would be at the end\n * or the minimum year would be at the beginning of a page.\n */\nfunction getStartingYear<D>(\n  dateAdapter: DateAdapter<D>, minDate: D | null, maxDate: D | null): number {\n  let startingYear = 0;\n  if (maxDate) {\n    const maxYear = dateAdapter.getYear(maxDate);\n    startingYear = maxYear - yearsPerPage + 1;\n  } else if (minDate) {\n    startingYear = dateAdapter.getYear(minDate);\n  }\n  return startingYear;\n}\n\n/** Gets remainder that is non-negative, even if first number is negative */\nfunction euclideanModulo (a: number, b: number): number {\n  return (a % b + b) % b;\n}\n"]}