nxt-pick-datetime 10.0.0 → 13.0.0

package/esm2020/lib/date-time/calendar-year-view/calendar-year-view.component.mjs

@@ -0,0 +1,369 @@
+import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes';
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, Inject, Input, Optional, Output, ViewChild } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { OWL_DATE_TIME_FORMATS } from '../../class/date-time-format.class';
+import { CalendarCell, OwlCalendarBodyComponent } from '../calendar-body/calendar-body.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../class/date-time-adapter.class";
+import * as i2 from "../calendar-body/calendar-body.component";
+const MONTHS_PER_YEAR = 12;
+const MONTHS_PER_ROW = 3;
+export class OwlYearViewComponent {
+    constructor(cdRef, dateTimeAdapter, dateTimeFormats) {
+        this.cdRef = cdRef;
+        this.dateTimeAdapter = dateTimeAdapter;
+        this.dateTimeFormats = dateTimeFormats;
+        /**
+         * The select mode of the picker;
+         * */
+        this._selectMode = 'single';
+        this._selecteds = [];
+        this.localeSub = Subscription.EMPTY;
+        this.initiated = false;
+        /**
+         * An array to hold all selectedDates' month value
+         * the value is the month number in current year
+         * */
+        this.selectedMonths = [];
+        /**
+         * Callback to invoke when a new month is selected
+         * */
+        this.change = new EventEmitter();
+        /**
+         * Emits the selected year. This doesn't imply a change on the selected date
+         * */
+        this.monthSelected = new EventEmitter();
+        /** Emits when any date is activated. */
+        this.pickerMomentChange = new EventEmitter();
+        /** Emits when use keyboard enter to select a calendar cell */
+        this.keyboardEnter = new EventEmitter();
+        this.monthNames = this.dateTimeAdapter.getMonthNames('short');
+    }
+    get selectMode() {
+        return this._selectMode;
+    }
+    set selectMode(val) {
+        this._selectMode = val;
+        if (this.initiated) {
+            this.generateMonthList();
+            this.cdRef.markForCheck();
+        }
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        value = this.dateTimeAdapter.deserialize(value);
+        this._selected = this.getValidDate(value);
+        this.setSelectedMonths();
+    }
+    get selecteds() {
+        return this._selecteds;
+    }
+    set selecteds(values) {
+        this._selecteds = [];
+        values.forEach(val => {
+            const value = this.dateTimeAdapter.deserialize(val);
+            this._selecteds.push(this.getValidDate(value));
+        });
+        this.setSelectedMonths();
+    }
+    get pickerMoment() {
+        return this._pickerMoment;
+    }
+    set pickerMoment(value) {
+        const oldMoment = this._pickerMoment;
+        value = this.dateTimeAdapter.deserialize(value);
+        this._pickerMoment =
+            this.getValidDate(value) || this.dateTimeAdapter.now();
+        if (!this.hasSameYear(oldMoment, this._pickerMoment) &&
+            this.initiated) {
+            this.generateMonthList();
+        }
+    }
+    get dateFilter() {
+        return this._dateFilter;
+    }
+    set dateFilter(filter) {
+        this._dateFilter = filter;
+        if (this.initiated) {
+            this.generateMonthList();
+        }
+    }
+    get minDate() {
+        return this._minDate;
+    }
+    set minDate(value) {
+        value = this.dateTimeAdapter.deserialize(value);
+        this._minDate = this.getValidDate(value);
+        if (this.initiated) {
+            this.generateMonthList();
+        }
+    }
+    get maxDate() {
+        return this._maxDate;
+    }
+    set maxDate(value) {
+        value = this.dateTimeAdapter.deserialize(value);
+        this._maxDate = this.getValidDate(value);
+        if (this.initiated) {
+            this.generateMonthList();
+        }
+    }
+    get months() {
+        return this._months;
+    }
+    get activeCell() {
+        if (this._pickerMoment) {
+            return this.dateTimeAdapter.getMonth(this._pickerMoment);
+        }
+    }
+    get isInSingleMode() {
+        return this.selectMode === 'single';
+    }
+    get isInRangeMode() {
+        return (this.selectMode === 'range' ||
+            this.selectMode === 'rangeFrom' ||
+            this.selectMode === 'rangeTo');
+    }
+    get owlDTCalendarView() {
+        return true;
+    }
+    ngOnInit() {
+        this.localeSub = this.dateTimeAdapter.localeChanges.subscribe(() => {
+            this.generateMonthList();
+            this.cdRef.markForCheck();
+        });
+    }
+    ngAfterContentInit() {
+        this.generateMonthList();
+        this.initiated = true;
+    }
+    ngOnDestroy() {
+        this.localeSub.unsubscribe();
+    }
+    /**
+     * Handle a calendarCell selected
+     */
+    selectCalendarCell(cell) {
+        this.selectMonth(cell.value);
+    }
+    /**
+     * Handle a new month selected
+     */
+    selectMonth(month) {
+        const firstDateOfMonth = this.dateTimeAdapter.createDate(this.dateTimeAdapter.getYear(this.pickerMoment), month, 1);
+        this.monthSelected.emit(firstDateOfMonth);
+        const daysInMonth = this.dateTimeAdapter.getNumDaysInMonth(firstDateOfMonth);
+        const result = this.dateTimeAdapter.createDate(this.dateTimeAdapter.getYear(this.pickerMoment), month, Math.min(daysInMonth, this.dateTimeAdapter.getDate(this.pickerMoment)), this.dateTimeAdapter.getHours(this.pickerMoment), this.dateTimeAdapter.getMinutes(this.pickerMoment), this.dateTimeAdapter.getSeconds(this.pickerMoment));
+        this.change.emit(result);
+    }
+    /**
+     * Handle keydown event on calendar body
+     */
+    handleCalendarKeydown(event) {
+        let moment;
+        switch (event.keyCode) {
+            // minus 1 month
+            case LEFT_ARROW:
+                moment = this.dateTimeAdapter.addCalendarMonths(this.pickerMoment, -1);
+                this.pickerMomentChange.emit(moment);
+                break;
+            // add 1 month
+            case RIGHT_ARROW:
+                moment = this.dateTimeAdapter.addCalendarMonths(this.pickerMoment, 1);
+                this.pickerMomentChange.emit(moment);
+                break;
+            // minus 3 months
+            case UP_ARROW:
+                moment = this.dateTimeAdapter.addCalendarMonths(this.pickerMoment, -3);
+                this.pickerMomentChange.emit(moment);
+                break;
+            // add 3 months
+            case DOWN_ARROW:
+                moment = this.dateTimeAdapter.addCalendarMonths(this.pickerMoment, 3);
+                this.pickerMomentChange.emit(moment);
+                break;
+            // move to first month of current year
+            case HOME:
+                moment = this.dateTimeAdapter.addCalendarMonths(this.pickerMoment, -this.dateTimeAdapter.getMonth(this.pickerMoment));
+                this.pickerMomentChange.emit(moment);
+                break;
+            // move to last month of current year
+            case END:
+                moment = this.dateTimeAdapter.addCalendarMonths(this.pickerMoment, 11 - this.dateTimeAdapter.getMonth(this.pickerMoment));
+                this.pickerMomentChange.emit(moment);
+                break;
+            // minus 1 year (or 10 year)
+            case PAGE_UP:
+                moment = this.dateTimeAdapter.addCalendarYears(this.pickerMoment, event.altKey ? -10 : -1);
+                this.pickerMomentChange.emit(moment);
+                break;
+            // add 1 year (or 10 year)
+            case PAGE_DOWN:
+                moment = this.dateTimeAdapter.addCalendarYears(this.pickerMoment, event.altKey ? 10 : 1);
+                this.pickerMomentChange.emit(moment);
+                break;
+            // Select current month
+            case ENTER:
+                this.selectMonth(this.dateTimeAdapter.getMonth(this.pickerMoment));
+                this.keyboardEnter.emit();
+                break;
+            default:
+                return;
+        }
+        this.focusActiveCell();
+        event.preventDefault();
+    }
+    /**
+     * Generate the calendar month list
+     * */
+    generateMonthList() {
+        if (!this.pickerMoment) {
+            return;
+        }
+        this.setSelectedMonths();
+        this.todayMonth = this.getMonthInCurrentYear(this.dateTimeAdapter.now());
+        this._months = [];
+        for (let i = 0; i < MONTHS_PER_YEAR / MONTHS_PER_ROW; i++) {
+            const row = [];
+            for (let j = 0; j < MONTHS_PER_ROW; j++) {
+                const month = j + i * MONTHS_PER_ROW;
+                const monthCell = this.createMonthCell(month);
+                row.push(monthCell);
+            }
+            this._months.push(row);
+        }
+        return;
+    }
+    /**
+     * Creates an CalendarCell for the given month.
+     */
+    createMonthCell(month) {
+        const startDateOfMonth = this.dateTimeAdapter.createDate(this.dateTimeAdapter.getYear(this.pickerMoment), month, 1);
+        const ariaLabel = this.dateTimeAdapter.format(startDateOfMonth, this.dateTimeFormats.monthYearA11yLabel);
+        const cellClass = 'owl-dt-month-' + month;
+        return new CalendarCell(month, this.monthNames[month], ariaLabel, this.isMonthEnabled(month), false, cellClass);
+    }
+    /**
+     * Check if the given month is enable
+     */
+    isMonthEnabled(month) {
+        const firstDateOfMonth = this.dateTimeAdapter.createDate(this.dateTimeAdapter.getYear(this.pickerMoment), month, 1);
+        // If any date in the month is selectable,
+        // we count the month as enable
+        for (let date = firstDateOfMonth; this.dateTimeAdapter.getMonth(date) === month; date = this.dateTimeAdapter.addCalendarDays(date, 1)) {
+            if (!!date &&
+                (!this.dateFilter || this.dateFilter(date, 'month')) &&
+                (!this.minDate ||
+                    this.dateTimeAdapter.compare(date, this.minDate) >= 0) &&
+                (!this.maxDate ||
+                    this.dateTimeAdapter.compare(date, this.maxDate) <= 0)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Gets the month in this year that the given Date falls on.
+     * Returns null if the given Date is in another year.
+     */
+    getMonthInCurrentYear(date) {
+        if (this.getValidDate(date) && this.getValidDate(this._pickerMoment)) {
+            const result = this.dateTimeAdapter.compareYear(date, this._pickerMoment);
+            // < 0 : the given date's year is before pickerMoment's year, we return -1 as selected month value.
+            // > 0 : the given date's year is after pickerMoment's year, we return 12 as selected month value.
+            // 0 : the give date's year is same as the pickerMoment's year, we return the actual month value.
+            if (result < 0) {
+                return -1;
+            }
+            else if (result > 0) {
+                return 12;
+            }
+            else {
+                return this.dateTimeAdapter.getMonth(date);
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Set the selectedMonths value
+     * In single mode, it has only one value which represent the month the selected date in
+     * In range mode, it would has two values, one for the month the fromValue in and the other for the month the toValue in
+     * */
+    setSelectedMonths() {
+        this.selectedMonths = [];
+        if (this.isInSingleMode && this.selected) {
+            this.selectedMonths[0] = this.getMonthInCurrentYear(this.selected);
+        }
+        if (this.isInRangeMode && this.selecteds) {
+            this.selectedMonths[0] = this.getMonthInCurrentYear(this.selecteds[0]);
+            this.selectedMonths[1] = this.getMonthInCurrentYear(this.selecteds[1]);
+        }
+    }
+    /**
+     * Check the given dates are in the same year
+     */
+    hasSameYear(dateLeft, dateRight) {
+        return !!(dateLeft &&
+            dateRight &&
+            this.dateTimeAdapter.getYear(dateLeft) ===
+                this.dateTimeAdapter.getYear(dateRight));
+    }
+    /**
+     * Get a valid date object
+     */
+    getValidDate(obj) {
+        return this.dateTimeAdapter.isDateInstance(obj) &&
+            this.dateTimeAdapter.isValid(obj)
+            ? obj
+            : null;
+    }
+    focusActiveCell() {
+        this.calendarBodyElm.focusActiveCell();
+    }
+}
+OwlYearViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlYearViewComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.DateTimeAdapter, optional: true }, { token: OWL_DATE_TIME_FORMATS, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+OwlYearViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: OwlYearViewComponent, selector: "owl-date-time-year-view", inputs: { selectMode: "selectMode", selected: "selected", selecteds: "selecteds", pickerMoment: "pickerMoment", dateFilter: "dateFilter", minDate: "minDate", maxDate: "maxDate" }, outputs: { change: "change", monthSelected: "monthSelected", pickerMomentChange: "pickerMomentChange", keyboardEnter: "keyboardEnter" }, host: { properties: { "class.owl-dt-calendar-view": "this.owlDTCalendarView" } }, viewQueries: [{ propertyName: "calendarBodyElm", first: true, predicate: OwlCalendarBodyComponent, descendants: true, static: true }], exportAs: ["owlMonthView"], ngImport: i0, template: "<table class=\"owl-dt-calendar-table owl-dt-calendar-year-table\">\n    <thead class=\"owl-dt-calendar-header\">\n        <tr>\n            <th class=\"owl-dt-calendar-table-divider\"\n                aria-hidden=\"true\"\n                colspan=\"3\"></th>\n        </tr>\n    </thead>\n    <tbody owl-date-time-calendar-body\n        role=\"grid\"\n        [rows]=\"months\"\n        [numCols]=\"3\"\n        [cellRatio]=\"3 / 7\"\n        [activeCell]=\"activeCell\"\n        [todayValue]=\"todayMonth\"\n        [selectedValues]=\"selectedMonths\"\n        [selectMode]=\"selectMode\"\n        (keydown)=\"handleCalendarKeydown($event)\"\n        (select)=\"selectCalendarCell($event)\">\n    </tbody>\n</table>\n", styles: [""], components: [{ type: i2.OwlCalendarBodyComponent, selector: "[owl-date-time-calendar-body]", inputs: ["activeCell", "rows", "numCols", "cellRatio", "todayValue", "selectedValues", "selectMode"], outputs: ["select"], exportAs: ["owlDateTimeCalendarBody"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlYearViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'owl-date-time-year-view', exportAs: 'owlMonthView', preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, template: "<table class=\"owl-dt-calendar-table owl-dt-calendar-year-table\">\n    <thead class=\"owl-dt-calendar-header\">\n        <tr>\n            <th class=\"owl-dt-calendar-table-divider\"\n                aria-hidden=\"true\"\n                colspan=\"3\"></th>\n        </tr>\n    </thead>\n    <tbody owl-date-time-calendar-body\n        role=\"grid\"\n        [rows]=\"months\"\n        [numCols]=\"3\"\n        [cellRatio]=\"3 / 7\"\n        [activeCell]=\"activeCell\"\n        [todayValue]=\"todayMonth\"\n        [selectedValues]=\"selectedMonths\"\n        [selectMode]=\"selectMode\"\n        (keydown)=\"handleCalendarKeydown($event)\"\n        (select)=\"selectCalendarCell($event)\">\n    </tbody>\n</table>\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.DateTimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DATE_TIME_FORMATS]
+                }] }]; }, propDecorators: { selectMode: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], selecteds: [{
+                type: Input
+            }], pickerMoment: [{
+                type: Input
+            }], dateFilter: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], monthSelected: [{
+                type: Output
+            }], pickerMomentChange: [{
+                type: Output
+            }], keyboardEnter: [{
+                type: Output
+            }], calendarBodyElm: [{
+                type: ViewChild,
+                args: [OwlCalendarBodyComponent, { static: true }]
+            }], owlDTCalendarView: [{
+                type: HostBinding,
+                args: ['class.owl-dt-calendar-view']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-year-view.component.js","sourceRoot":"","sources":["../../../../../../projects/nxt-pick-datetime/src/lib/date-time/calendar-year-view/calendar-year-view.component.ts","../../../../../../projects/nxt-pick-datetime/src/lib/date-time/calendar-year-view/calendar-year-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes'\nimport { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, HostBinding, Inject, Input, OnDestroy, OnInit, Optional, Output, ViewChild } from '@angular/core'\nimport { Subscription } from 'rxjs'\nimport { DateTimeAdapter } from '../../class/date-time-adapter.class'\nimport { OwlDateTimeFormats, OWL_DATE_TIME_FORMATS } from '../../class/date-time-format.class'\nimport { DateFilter, SelectMode } from '../../class/date-time.class'\nimport { CalendarCell, OwlCalendarBodyComponent } from '../calendar-body/calendar-body.component'\n\nconst MONTHS_PER_YEAR = 12\nconst MONTHS_PER_ROW = 3\n\n@Component({\n    selector: 'owl-date-time-year-view',\n    exportAs: 'owlMonthView',\n    templateUrl: './calendar-year-view.component.html',\n    styleUrls: ['./calendar-year-view.component.scss'],\n    preserveWhitespaces: false,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class OwlYearViewComponent<T>\n    implements OnInit, AfterContentInit, OnDestroy {\n    /**\n     * The select mode of the picker;\n     * */\n    private _selectMode: SelectMode = 'single'\n    @Input()\n    get selectMode(): SelectMode {\n        return this._selectMode\n    }\n\n    set selectMode(val: SelectMode) {\n        this._selectMode = val\n        if (this.initiated) {\n            this.generateMonthList()\n            this.cdRef.markForCheck()\n        }\n    }\n\n    /** The currently selected date. */\n    private _selected: T | null\n    @Input()\n    get selected(): T | null {\n        return this._selected\n    }\n\n    set selected(value: T | null) {\n        value = this.dateTimeAdapter.deserialize(value)\n        this._selected = this.getValidDate(value)\n        this.setSelectedMonths()\n    }\n\n    private _selecteds: T[] = []\n    @Input()\n    get selecteds(): T[] {\n        return this._selecteds\n    }\n\n    set selecteds(values: T[]) {\n        this._selecteds = []\n        values.forEach(val => {\n            const value = this.dateTimeAdapter.deserialize(val)\n            this._selecteds.push(this.getValidDate(value))\n        })\n\n        this.setSelectedMonths()\n    }\n\n    private _pickerMoment: T | null\n    @Input()\n    get pickerMoment() {\n        return this._pickerMoment\n    }\n\n    set pickerMoment(value: T) {\n        const oldMoment = this._pickerMoment\n        value = this.dateTimeAdapter.deserialize(value)\n        this._pickerMoment =\n            this.getValidDate(value) || this.dateTimeAdapter.now()\n\n        if (\n            !this.hasSameYear(oldMoment, this._pickerMoment) &&\n            this.initiated\n        ) {\n            this.generateMonthList()\n        }\n    }\n\n    /**\n     * A function used to filter which dates are selectable\n     * */\n    private _dateFilter: DateFilter<T>\n    @Input()\n    get dateFilter() {\n        return this._dateFilter\n    }\n\n    set dateFilter(filter: DateFilter<T>) {\n        this._dateFilter = filter\n        if (this.initiated) {\n            this.generateMonthList()\n        }\n    }\n\n    /** The minimum selectable date. */\n    private _minDate: T | null\n    @Input()\n    get minDate(): T | null {\n        return this._minDate\n    }\n\n    set minDate(value: T | null) {\n        value = this.dateTimeAdapter.deserialize(value)\n        this._minDate = this.getValidDate(value)\n        if (this.initiated) {\n            this.generateMonthList()\n        }\n    }\n\n    /** The maximum selectable date. */\n    private _maxDate: T | null\n    @Input()\n    get maxDate(): T | null {\n        return this._maxDate\n    }\n\n    set maxDate(value: T | null) {\n        value = this.dateTimeAdapter.deserialize(value)\n        this._maxDate = this.getValidDate(value)\n        if (this.initiated) {\n            this.generateMonthList()\n        }\n    }\n\n    private readonly monthNames: string[]\n\n    private _months: CalendarCell[][]\n    get months() {\n        return this._months\n    }\n\n    get activeCell(): number {\n        if (this._pickerMoment) {\n            return this.dateTimeAdapter.getMonth(this._pickerMoment)\n        }\n    }\n\n    get isInSingleMode(): boolean {\n        return this.selectMode === 'single'\n    }\n\n    get isInRangeMode(): boolean {\n        return (\n            this.selectMode === 'range' ||\n            this.selectMode === 'rangeFrom' ||\n            this.selectMode === 'rangeTo'\n        )\n    }\n\n    private localeSub: Subscription = Subscription.EMPTY\n\n    private initiated = false\n\n    public todayMonth: number | null\n\n    /**\n     * An array to hold all selectedDates' month value\n     * the value is the month number in current year\n     * */\n    public selectedMonths: number[] = []\n\n    /**\n     * Callback to invoke when a new month is selected\n     * */\n    @Output()\n    // eslint-disable-next-line @angular-eslint/no-output-native\n    readonly change = new EventEmitter<T>()\n\n    /**\n     * Emits the selected year. This doesn't imply a change on the selected date\n     * */\n    @Output()\n    readonly monthSelected = new EventEmitter<T>()\n\n    /** Emits when any date is activated. */\n    @Output()\n    readonly pickerMomentChange: EventEmitter<T> = new EventEmitter<T>()\n\n    /** Emits when use keyboard enter to select a calendar cell */\n    @Output()\n    readonly keyboardEnter: EventEmitter<any> = new EventEmitter<any>()\n\n    /** The body of calendar table */\n    @ViewChild(OwlCalendarBodyComponent, { static: true })\n    calendarBodyElm: OwlCalendarBodyComponent\n\n    @HostBinding('class.owl-dt-calendar-view')\n    get owlDTCalendarView(): boolean {\n        return true\n    }\n\n    constructor(\n        private cdRef: ChangeDetectorRef,\n        @Optional() private dateTimeAdapter: DateTimeAdapter<T>,\n        @Optional()\n        @Inject(OWL_DATE_TIME_FORMATS)\n        private dateTimeFormats: OwlDateTimeFormats\n    ) {\n        this.monthNames = this.dateTimeAdapter.getMonthNames('short')\n    }\n\n    public ngOnInit() {\n        this.localeSub = this.dateTimeAdapter.localeChanges.subscribe(() => {\n            this.generateMonthList()\n            this.cdRef.markForCheck()\n        })\n    }\n\n    public ngAfterContentInit(): void {\n        this.generateMonthList()\n        this.initiated = true\n    }\n\n    public ngOnDestroy(): void {\n        this.localeSub.unsubscribe()\n    }\n\n    /**\n     * Handle a calendarCell selected\n     */\n    public selectCalendarCell(cell: CalendarCell): void {\n        this.selectMonth(cell.value)\n    }\n\n    /**\n     * Handle a new month selected\n     */\n    private selectMonth(month: number): void {\n        const firstDateOfMonth = this.dateTimeAdapter.createDate(\n            this.dateTimeAdapter.getYear(this.pickerMoment),\n            month,\n            1\n        )\n\n        this.monthSelected.emit(firstDateOfMonth)\n\n        const daysInMonth = this.dateTimeAdapter.getNumDaysInMonth(\n            firstDateOfMonth\n        )\n        const result = this.dateTimeAdapter.createDate(\n            this.dateTimeAdapter.getYear(this.pickerMoment),\n            month,\n            Math.min(\n                daysInMonth,\n                this.dateTimeAdapter.getDate(this.pickerMoment)\n            ),\n            this.dateTimeAdapter.getHours(this.pickerMoment),\n            this.dateTimeAdapter.getMinutes(this.pickerMoment),\n            this.dateTimeAdapter.getSeconds(this.pickerMoment)\n        )\n\n        this.change.emit(result)\n    }\n\n    /**\n     * Handle keydown event on calendar body\n     */\n    public handleCalendarKeydown(event: KeyboardEvent): void {\n        let moment\n        switch (event.keyCode) {\n            // minus 1 month\n            case LEFT_ARROW:\n                moment = this.dateTimeAdapter.addCalendarMonths(\n                    this.pickerMoment,\n                    -1\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // add 1 month\n            case RIGHT_ARROW:\n                moment = this.dateTimeAdapter.addCalendarMonths(\n                    this.pickerMoment,\n                    1\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // minus 3 months\n            case UP_ARROW:\n                moment = this.dateTimeAdapter.addCalendarMonths(\n                    this.pickerMoment,\n                    -3\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // add 3 months\n            case DOWN_ARROW:\n                moment = this.dateTimeAdapter.addCalendarMonths(\n                    this.pickerMoment,\n                    3\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // move to first month of current year\n            case HOME:\n                moment = this.dateTimeAdapter.addCalendarMonths(\n                    this.pickerMoment,\n                    -this.dateTimeAdapter.getMonth(this.pickerMoment)\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // move to last month of current year\n            case END:\n                moment = this.dateTimeAdapter.addCalendarMonths(\n                    this.pickerMoment,\n                    11 - this.dateTimeAdapter.getMonth(this.pickerMoment)\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // minus 1 year (or 10 year)\n            case PAGE_UP:\n                moment = this.dateTimeAdapter.addCalendarYears(\n                    this.pickerMoment,\n                    event.altKey ? -10 : -1\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // add 1 year (or 10 year)\n            case PAGE_DOWN:\n                moment = this.dateTimeAdapter.addCalendarYears(\n                    this.pickerMoment,\n                    event.altKey ? 10 : 1\n                )\n                this.pickerMomentChange.emit(moment)\n                break\n\n            // Select current month\n            case ENTER:\n                this.selectMonth(\n                    this.dateTimeAdapter.getMonth(this.pickerMoment)\n                )\n                this.keyboardEnter.emit()\n                break\n            default:\n                return\n        }\n\n        this.focusActiveCell()\n        event.preventDefault()\n    }\n\n    /**\n     * Generate the calendar month list\n     * */\n    private generateMonthList(): void {\n        if (!this.pickerMoment) {\n            return\n        }\n\n        this.setSelectedMonths()\n        this.todayMonth = this.getMonthInCurrentYear(\n            this.dateTimeAdapter.now()\n        )\n\n        this._months = []\n        for (let i = 0; i < MONTHS_PER_YEAR / MONTHS_PER_ROW; i++) {\n            const row = []\n\n            for (let j = 0; j < MONTHS_PER_ROW; j++) {\n                const month = j + i * MONTHS_PER_ROW\n                const monthCell = this.createMonthCell(month)\n                row.push(monthCell)\n            }\n\n            this._months.push(row)\n        }\n\n        return\n    }\n\n    /**\n     * Creates an CalendarCell for the given month.\n     */\n    private createMonthCell(month: number): CalendarCell {\n        const startDateOfMonth = this.dateTimeAdapter.createDate(\n            this.dateTimeAdapter.getYear(this.pickerMoment),\n            month,\n            1\n        )\n        const ariaLabel = this.dateTimeAdapter.format(\n            startDateOfMonth,\n            this.dateTimeFormats.monthYearA11yLabel\n        )\n        const cellClass = 'owl-dt-month-' + month\n        return new CalendarCell(\n            month,\n            this.monthNames[month],\n            ariaLabel,\n            this.isMonthEnabled(month),\n            false,\n            cellClass\n        )\n    }\n\n    /**\n     * Check if the given month is enable\n     */\n    private isMonthEnabled(month: number): boolean {\n        const firstDateOfMonth = this.dateTimeAdapter.createDate(\n            this.dateTimeAdapter.getYear(this.pickerMoment),\n            month,\n            1\n        )\n\n        // If any date in the month is selectable,\n        // we count the month as enable\n        for (\n            let date = firstDateOfMonth;\n            this.dateTimeAdapter.getMonth(date) === month;\n            date = this.dateTimeAdapter.addCalendarDays(date, 1)\n        ) {\n            if (\n                !!date &&\n                (!this.dateFilter || this.dateFilter(date, 'month')) &&\n                (!this.minDate ||\n                    this.dateTimeAdapter.compare(date, this.minDate) >= 0) &&\n                (!this.maxDate ||\n                    this.dateTimeAdapter.compare(date, this.maxDate) <= 0)\n            ) {\n                return true\n            }\n        }\n\n        return false\n    }\n\n    /**\n     * Gets the month in this year that the given Date falls on.\n     * Returns null if the given Date is in another year.\n     */\n    private getMonthInCurrentYear(date: T | null): number {\n        if (this.getValidDate(date) && this.getValidDate(this._pickerMoment)) {\n            const result = this.dateTimeAdapter.compareYear(\n                date,\n                this._pickerMoment\n            )\n\n            // < 0 : the given date's year is before pickerMoment's year, we return -1 as selected month value.\n            // > 0 : the given date's year is after pickerMoment's year, we return 12 as selected month value.\n            // 0 : the give date's year is same as the pickerMoment's year, we return the actual month value.\n            if (result < 0) {\n                return -1\n            } else if (result > 0) {\n                return 12\n            } else {\n                return this.dateTimeAdapter.getMonth(date)\n            }\n        } else {\n            return null\n        }\n    }\n\n    /**\n     * Set the selectedMonths value\n     * In single mode, it has only one value which represent the month the selected date in\n     * In range mode, it would has two values, one for the month the fromValue in and the other for the month the toValue in\n     * */\n    private setSelectedMonths(): void {\n        this.selectedMonths = []\n        if (this.isInSingleMode && this.selected) {\n            this.selectedMonths[0] = this.getMonthInCurrentYear(this.selected)\n        }\n\n        if (this.isInRangeMode && this.selecteds) {\n            this.selectedMonths[0] = this.getMonthInCurrentYear(\n                this.selecteds[0]\n            )\n            this.selectedMonths[1] = this.getMonthInCurrentYear(\n                this.selecteds[1]\n            )\n        }\n    }\n\n    /**\n     * Check the given dates are in the same year\n     */\n    private hasSameYear(dateLeft: T, dateRight: T) {\n        return !!(\n            dateLeft &&\n            dateRight &&\n            this.dateTimeAdapter.getYear(dateLeft) ===\n            this.dateTimeAdapter.getYear(dateRight)\n        )\n    }\n\n    /**\n     * Get a valid date object\n     */\n    private getValidDate(obj: any): T | null {\n        return this.dateTimeAdapter.isDateInstance(obj) &&\n            this.dateTimeAdapter.isValid(obj)\n            ? obj\n            : null\n    }\n\n    private focusActiveCell() {\n        this.calendarBodyElm.focusActiveCell()\n    }\n}\n","<table class=\"owl-dt-calendar-table owl-dt-calendar-year-table\">\n    <thead class=\"owl-dt-calendar-header\">\n        <tr>\n            <th class=\"owl-dt-calendar-table-divider\"\n                aria-hidden=\"true\"\n                colspan=\"3\"></th>\n        </tr>\n    </thead>\n    <tbody owl-date-time-calendar-body\n        role=\"grid\"\n        [rows]=\"months\"\n        [numCols]=\"3\"\n        [cellRatio]=\"3 / 7\"\n        [activeCell]=\"activeCell\"\n        [todayValue]=\"todayMonth\"\n        [selectedValues]=\"selectedMonths\"\n        [selectMode]=\"selectMode\"\n        (keydown)=\"handleCalendarKeydown($event)\"\n        (select)=\"selectCalendarCell($event)\">\n    </tbody>\n</table>\n"]}