source: trip-planner-front/node_modules/@angular/material/esm2015/datepicker/multi-year-view.js@ 59329aa

Last change on this file since 59329aa was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 43.7 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, UP_ARROW, SPACE, } from '@angular/cdk/keycodes';
9import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/core';
10import { DateAdapter } from '@angular/material/core';
11import { Directionality } from '@angular/cdk/bidi';
12import { MatCalendarBody, MatCalendarCell, } from './calendar-body';
13import { createMissingDateImplError } from './datepicker-errors';
14import { Subscription } from 'rxjs';
15import { startWith } from 'rxjs/operators';
16import { DateRange } from './date-selection-model';
17export const yearsPerPage = 24;
18export const yearsPerRow = 4;
19/**
20 * An internal component used to display a year selector in the datepicker.
21 * @docs-private
22 */
23export class MatMultiYearView {
24 constructor(_changeDetectorRef, _dateAdapter, _dir) {
25 this._changeDetectorRef = _changeDetectorRef;
26 this._dateAdapter = _dateAdapter;
27 this._dir = _dir;
28 this._rerenderSubscription = Subscription.EMPTY;
29 /** Emits when a new year is selected. */
30 this.selectedChange = new EventEmitter();
31 /** Emits the selected year. This doesn't imply a change on the selected date */
32 this.yearSelected = new EventEmitter();
33 /** Emits when any date is activated. */
34 this.activeDateChange = new EventEmitter();
35 if (!this._dateAdapter && (typeof ngDevMode === 'undefined' || ngDevMode)) {
36 throw createMissingDateImplError('DateAdapter');
37 }
38 this._activeDate = this._dateAdapter.today();
39 }
40 /** The date to display in this multi-year view (everything other than the year is ignored). */
41 get activeDate() { return this._activeDate; }
42 set activeDate(value) {
43 let oldActiveDate = this._activeDate;
44 const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();
45 this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);
46 if (!isSameMultiYearView(this._dateAdapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {
47 this._init();
48 }
49 }
50 /** The currently selected date. */
51 get selected() { return this._selected; }
52 set selected(value) {
53 if (value instanceof DateRange) {
54 this._selected = value;
55 }
56 else {
57 this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
58 }
59 this._setSelectedYear(value);
60 }
61 /** The minimum selectable date. */
62 get minDate() { return this._minDate; }
63 set minDate(value) {
64 this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
65 }
66 /** The maximum selectable date. */
67 get maxDate() { return this._maxDate; }
68 set maxDate(value) {
69 this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
70 }
71 ngAfterContentInit() {
72 this._rerenderSubscription = this._dateAdapter.localeChanges
73 .pipe(startWith(null))
74 .subscribe(() => this._init());
75 }
76 ngOnDestroy() {
77 this._rerenderSubscription.unsubscribe();
78 }
79 /** Initializes this multi-year view. */
80 _init() {
81 this._todayYear = this._dateAdapter.getYear(this._dateAdapter.today());
82 // We want a range years such that we maximize the number of
83 // enabled dates visible at once. This prevents issues where the minimum year
84 // is the last item of a page OR the maximum year is the first item of a page.
85 // The offset from the active year to the "slot" for the starting year is the
86 // *actual* first rendered year in the multi-year view.
87 const activeYear = this._dateAdapter.getYear(this._activeDate);
88 const minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);
89 this._years = [];
90 for (let i = 0, row = []; i < yearsPerPage; i++) {
91 row.push(minYearOfPage + i);
92 if (row.length == yearsPerRow) {
93 this._years.push(row.map(year => this._createCellForYear(year)));
94 row = [];
95 }
96 }
97 this._changeDetectorRef.markForCheck();
98 }
99 /** Handles when a new year is selected. */
100 _yearSelected(event) {
101 const year = event.value;
102 this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1));
103 let month = this._dateAdapter.getMonth(this.activeDate);
104 let daysInMonth = this._dateAdapter.getNumDaysInMonth(this._dateAdapter.createDate(year, month, 1));
105 this.selectedChange.emit(this._dateAdapter.createDate(year, month, Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));
106 }
107 /** Handles keydown events on the calendar body when calendar is in multi-year view. */
108 _handleCalendarBodyKeydown(event) {
109 const oldActiveDate = this._activeDate;
110 const isRtl = this._isRtl();
111 switch (event.keyCode) {
112 case LEFT_ARROW:
113 this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? 1 : -1);
114 break;
115 case RIGHT_ARROW:
116 this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? -1 : 1);
117 break;
118 case UP_ARROW:
119 this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -yearsPerRow);
120 break;
121 case DOWN_ARROW:
122 this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerRow);
123 break;
124 case HOME:
125 this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate));
126 break;
127 case END:
128 this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerPage - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate) - 1);
129 break;
130 case PAGE_UP:
131 this.activeDate =
132 this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);
133 break;
134 case PAGE_DOWN:
135 this.activeDate =
136 this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);
137 break;
138 case ENTER:
139 case SPACE:
140 // Note that we only prevent the default action here while the selection happens in
141 // `keyup` below. We can't do the selection here, because it can cause the calendar to
142 // reopen if focus is restored immediately. We also can't call `preventDefault` on `keyup`
143 // because it's too late (see #23305).
144 this._selectionKeyPressed = true;
145 break;
146 default:
147 // Don't prevent default or focus active cell on keys that we don't explicitly handle.
148 return;
149 }
150 if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {
151 this.activeDateChange.emit(this.activeDate);
152 }
153 this._focusActiveCell();
154 // Prevent unexpected default actions such as form submission.
155 event.preventDefault();
156 }
157 /** Handles keyup events on the calendar body when calendar is in multi-year view. */
158 _handleCalendarBodyKeyup(event) {
159 if (event.keyCode === SPACE || event.keyCode === ENTER) {
160 if (this._selectionKeyPressed) {
161 this._yearSelected({ value: this._dateAdapter.getYear(this._activeDate), event });
162 }
163 this._selectionKeyPressed = false;
164 }
165 }
166 _getActiveCell() {
167 return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);
168 }
169 /** Focuses the active cell after the microtask queue is empty. */
170 _focusActiveCell() {
171 this._matCalendarBody._focusActiveCell();
172 }
173 /** Creates an MatCalendarCell for the given year. */
174 _createCellForYear(year) {
175 const date = this._dateAdapter.createDate(year, 0, 1);
176 const yearName = this._dateAdapter.getYearName(date);
177 const cellClasses = this.dateClass ? this.dateClass(date, 'multi-year') : undefined;
178 return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year), cellClasses);
179 }
180 /** Whether the given year is enabled. */
181 _shouldEnableYear(year) {
182 // disable if the year is greater than maxDate lower than minDate
183 if (year === undefined || year === null ||
184 (this.maxDate && year > this._dateAdapter.getYear(this.maxDate)) ||
185 (this.minDate && year < this._dateAdapter.getYear(this.minDate))) {
186 return false;
187 }
188 // enable if it reaches here and there's no filter defined
189 if (!this.dateFilter) {
190 return true;
191 }
192 const firstOfYear = this._dateAdapter.createDate(year, 0, 1);
193 // If any date in the year is enabled count the year as enabled.
194 for (let date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) {
195 if (this.dateFilter(date)) {
196 return true;
197 }
198 }
199 return false;
200 }
201 /** Determines whether the user has the RTL layout direction. */
202 _isRtl() {
203 return this._dir && this._dir.value === 'rtl';
204 }
205 /** Sets the currently-highlighted year based on a model value. */
206 _setSelectedYear(value) {
207 this._selectedYear = null;
208 if (value instanceof DateRange) {
209 const displayValue = value.start || value.end;
210 if (displayValue) {
211 this._selectedYear = this._dateAdapter.getYear(displayValue);
212 }
213 }
214 else if (value) {
215 this._selectedYear = this._dateAdapter.getYear(value);
216 }
217 }
218}
219MatMultiYearView.decorators = [
220 { type: Component, args: [{
221 selector: 'mat-multi-year-view',
222 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",
223 exportAs: 'matMultiYearView',
224 encapsulation: ViewEncapsulation.None,
225 changeDetection: ChangeDetectionStrategy.OnPush
226 },] }
227];
228MatMultiYearView.ctorParameters = () => [
229 { type: ChangeDetectorRef },
230 { type: DateAdapter, decorators: [{ type: Optional }] },
231 { type: Directionality, decorators: [{ type: Optional }] }
232];
233MatMultiYearView.propDecorators = {
234 activeDate: [{ type: Input }],
235 selected: [{ type: Input }],
236 minDate: [{ type: Input }],
237 maxDate: [{ type: Input }],
238 dateFilter: [{ type: Input }],
239 dateClass: [{ type: Input }],
240 selectedChange: [{ type: Output }],
241 yearSelected: [{ type: Output }],
242 activeDateChange: [{ type: Output }],
243 _matCalendarBody: [{ type: ViewChild, args: [MatCalendarBody,] }]
244};
245export function isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {
246 const year1 = dateAdapter.getYear(date1);
247 const year2 = dateAdapter.getYear(date2);
248 const startingYear = getStartingYear(dateAdapter, minDate, maxDate);
249 return Math.floor((year1 - startingYear) / yearsPerPage) ===
250 Math.floor((year2 - startingYear) / yearsPerPage);
251}
252/**
253 * When the multi-year view is first opened, the active year will be in view.
254 * So we compute how many years are between the active year and the *slot* where our
255 * "startingYear" will render when paged into view.
256 */
257export function getActiveOffset(dateAdapter, activeDate, minDate, maxDate) {
258 const activeYear = dateAdapter.getYear(activeDate);
259 return euclideanModulo((activeYear - getStartingYear(dateAdapter, minDate, maxDate)), yearsPerPage);
260}
261/**
262 * We pick a "starting" year such that either the maximum year would be at the end
263 * or the minimum year would be at the beginning of a page.
264 */
265function getStartingYear(dateAdapter, minDate, maxDate) {
266 let startingYear = 0;
267 if (maxDate) {
268 const maxYear = dateAdapter.getYear(maxDate);
269 startingYear = maxYear - yearsPerPage + 1;
270 }
271 else if (minDate) {
272 startingYear = dateAdapter.getYear(minDate);
273 }
274 return startingYear;
275}
276/** Gets remainder that is non-negative, even if first number is negative */
277function euclideanModulo(a, b) {
278 return (a % b + b) % b;
279}
280//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-year-view.js","sourceRoot":"","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"]}
Note: See TracBrowser for help on using the repository browser.