You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
332 lines
49 KiB
332 lines
49 KiB
/**
|
|
* @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: "<table class=\"mat-calendar-table\" role=\"grid\">\n <thead aria-hidden=\"true\" class=\"mat-calendar-table-header\">\n <tr><th class=\"mat-calendar-table-header-divider\" colspan=\"4\"></th></tr>\n </thead>\n <tbody mat-calendar-body\n [rows]=\"_years\"\n [todayValue]=\"_todayYear\"\n [startValue]=\"_selectedYear!\"\n [endValue]=\"_selectedYear!\"\n [numCols]=\"4\"\n [cellAspectRatio]=\"4 / 7\"\n [activeCell]=\"_getActiveCell()\"\n (selectedValueChange)=\"_yearSelected($event)\"\n (keyup)=\"_handleCalendarBodyKeyup($event)\"\n (keydown)=\"_handleCalendarBodyKeydown($event)\">\n </tbody>\n</table>\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":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\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"]}
|