fundamental-ngx
Version:
SAP Fundamentals, implemented in Angular
758 lines • 76.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, ElementRef, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
import { CalendarI18n } from '../../i18n/calendar-i18n';
import { FdDate } from '../../models/fd-date';
import { CalendarService } from '../../calendar.service';
import { Subject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';
/**
* Component representing the day view of the calendar.
*/
export class CalendarDayViewComponent {
/**
* @hidden
* @param {?} calendarI18n
* @param {?} eRef
*/
constructor(calendarI18n, eRef) {
this.calendarI18n = calendarI18n;
this.eRef = eRef;
/**
* @hidden
*/
this.newFocusedDayId = '';
/**
* An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)
*/
this.onDestroy$ = new Subject();
/**
* @hidden
*/
this.fdCalendarDateViewClass = true;
/**
* The type of calendar, 'single' for single date selection or 'range' for a range of dates.
*/
this.calType = 'single';
/**
* Event emitted always, when model is changed in range mode
*/
this.selectedRangeDateChange = new EventEmitter();
/**
* Event emitted always, when next month is selected, by focus
*/
this.nextMonthSelect = new EventEmitter();
/**
* Event emitted always, when previous month is selected, by focus
*/
this.previousMonthSelect = new EventEmitter();
/**
* Event emitted always, when model is changed in single mode
*/
this.selectedDateChange = new EventEmitter();
/**
* Function used to disable certain dates in the calendar.
* @param fdDate FdDate
*/
this.disableFunction = (/**
* @param {?} fdDate
* @return {?}
*/
function (fdDate) {
return false;
});
/**
* Function used to disable certain dates in the calendar for the range start selection.
* @param fdDate FdDate
*/
this.disableRangeStartFunction = (/**
* @param {?} fdDate
* @return {?}
*/
function (fdDate) {
return false;
});
/**
* Function used to disable certain dates in the calendar for the range end selection.
* @param fdDate FdDate
*/
this.disableRangeEndFunction = (/**
* @param {?} fdDate
* @return {?}
*/
function (fdDate) {
return false;
});
/**
* Function used to block certain dates in the calendar for the range start selection.
* @param fdDate FdDate
*/
this.blockRangeStartFunction = (/**
* @param {?} fdDate
* @return {?}
*/
function (fdDate) {
return false;
});
/**
* Function used to block certain dates in the calendar for the range end selection.
* @param fdDate FdDate
*/
this.blockRangeEndFunction = (/**
* @param {?} fdDate
* @return {?}
*/
function (fdDate) {
return false;
});
/**
* Function used to block certain dates in the calendar.
* @param fdDate FdDate
*/
this.blockFunction = (/**
* @param {?} fdDate
* @return {?}
*/
function (fdDate) {
return false;
});
}
/**
* Function for selecting a date on the calendar. Typically called when a date is clicked, but can also be called programmatically.
* @param {?} day CalendarDay object to be selected.
* @param {?=} event
* @return {?}
*/
selectDate(day, event) {
if (event) {
/**
* There are some problems with popup integration. After clicking inside day component, the popover closes.
*/
event.stopPropagation();
event.preventDefault();
this.newFocusedDayId = day.id;
this.focusElement(this.newFocusedDayId);
}
if (!day.blocked && !day.disabled) {
if (this.calType === 'single') {
this.selectedDate = day.date;
this.selectedDateChange.emit(day.date);
this.buildDayViewGrid();
}
else {
if (this.selectCounter === 0 || this.selectCounter === 2) {
this.selectedRangeDate = { start: day.date, end: null };
this.selectedRangeDateChange.emit(this.selectedRangeDate);
this.buildDayViewGrid();
}
else if (this.selectCounter === 1) {
// Check if date picked is higher than already chosen, otherwise just first one
if (this.selectedRangeDate.start.getTimeStamp() < day.date.getTimeStamp()) {
this.selectedRangeDate = { start: this.selectedRangeDate.start, end: day.date };
}
else {
this.selectedRangeDate = { start: day.date, end: null };
}
this.selectedRangeDateChange.emit(this.selectedRangeDate);
this.buildDayViewGrid();
}
}
}
}
/**
* @hidden
* @return {?}
*/
ngOnInit() {
this.buildDayViewGrid();
this.shortWeekDays = this.getShortWeekDays();
this.calendarI18n.i18nChange
.pipe(takeUntil(this.onDestroy$))
.subscribe((/**
* @return {?}
*/
() => this.shortWeekDays = this.getShortWeekDays()));
}
/**
* @hidden
* Amount of selected days
* 0, when none,
* 1, when only startDate, or endDate same as startDate,
* 2, when both
* @return {?}
*/
get selectCounter() {
if (!this.selectedRangeDate || !this.selectedRangeDate.start) {
return 0;
}
else if (this.selectedRangeDate.start &&
(!this.selectedRangeDate.end ||
CalendarService.datesEqual(this.selectedRangeDate.start, this.selectedRangeDate.end))) {
return 1;
}
else if (this.selectedRangeDate.start && this.selectedRangeDate.end) {
return 2;
}
}
/**
* @hidden
* Method that handles day cells keydown events,
* @param {?} event KeyboardEvent
* @param {?} cell CalendarDay
* @param {?} grid with specified column and row as a x and y
* @return {?}
*/
onKeydownDayHandler(event, cell, grid) {
if (event.code === 'Tab' && !event.shiftKey) {
if (this.focusEscapeFunction) {
event.preventDefault();
this.focusEscapeFunction();
}
}
else {
switch (event.code) {
case ('Space'):
case ('Enter'): {
event.preventDefault();
this.selectDate(cell);
this.newFocusedDayId = cell.id;
break;
}
case ('ArrowUp'): {
event.preventDefault();
if (grid.y > 0) {
this.newFocusedDayId = this.dayViewGrid[grid.y - 1][grid.x].id;
}
else {
this.selectPreviousMonth();
this.newFocusedDayId = this.dayViewGrid[this.dayViewGrid.length - 1][grid.x].id;
}
break;
}
case ('ArrowDown'): {
event.preventDefault();
if (grid.y < this.dayViewGrid.length - 1) {
this.newFocusedDayId = this.dayViewGrid[grid.y + 1][grid.x].id;
}
else {
this.selectNextMonth();
this.newFocusedDayId = this.dayViewGrid[0][grid.x].id;
}
break;
}
case ('ArrowLeft'): {
event.preventDefault();
if (grid.x > 0) {
this.newFocusedDayId = this.dayViewGrid[grid.y][grid.x - 1].id;
}
else if (grid.y > 0) {
this.newFocusedDayId = this.dayViewGrid[grid.y - 1][this.dayViewGrid[0].length - 1].id;
}
else {
this.selectPreviousMonth();
this.newFocusedDayId =
this.dayViewGrid[this.dayViewGrid.length - 1][this.dayViewGrid[0].length - 1].id;
}
break;
}
case ('ArrowRight'): {
event.preventDefault();
if (grid.x < this.dayViewGrid[0].length - 1) {
this.newFocusedDayId = this.dayViewGrid[grid.y][grid.x + 1].id;
}
else if (grid.y < this.dayViewGrid.length - 1) {
this.newFocusedDayId = this.dayViewGrid[grid.y + 1][0].id;
}
else {
this.selectNextMonth();
this.newFocusedDayId = this.dayViewGrid[0][0].id;
}
break;
}
}
}
if (this.newFocusedDayId) {
this.focusElement(this.newFocusedDayId);
}
}
/**
* @hidden
* @return {?}
*/
ngOnChanges() {
this.buildDayViewGrid();
}
/**
* @hidden
* @return {?}
*/
ngAfterViewChecked() {
if (this.newFocusedDayId) {
this.focusElement(this.newFocusedDayId);
this.newFocusedDayId = null;
}
}
/**
* @hidden
* Method that allow to focus elements inside this component
* @param {?} elementSelector
* @return {?}
*/
focusElement(elementSelector) {
/** @type {?} */
const elementToFocus = this.eRef.nativeElement.querySelector('#' + elementSelector);
if (elementToFocus) {
elementToFocus.focus();
}
}
/**
* Active day means that with tabindex = 0, it's selected day or today or first day
* @return {?}
*/
focusActiveDay() {
this.newFocusedDayId = this.getActiveCell(this.calendarDayList.filter((/**
* @param {?} cell
* @return {?}
*/
cell => cell.monthStatus === 'current'))).id;
}
/**
* Function that gives array of all displayed CalendarDays
* @return {?}
*/
get calendarDayList() {
return this.dayViewGrid.reduce((/**
* @param {?} totalCalendarRows
* @param {?} calendarRow
* @return {?}
*/
(totalCalendarRows, calendarRow) => {
if (!calendarRow) {
calendarRow = [];
}
return totalCalendarRows.concat(calendarRow);
}));
}
/**
* Method that selects previous month
* Triggered only when the month is changed during changing focus
* Also triggers event to parent calendar component and rebuilds day view grid
* @private
* @return {?}
*/
selectPreviousMonth() {
if (this.currentlyDisplayed.month > 1) {
this.currentlyDisplayed = Object.assign({}, this.currentlyDisplayed, { month: this.currentlyDisplayed.month - 1 });
}
else {
this.currentlyDisplayed = { year: this.currentlyDisplayed.year - 1, month: 12 };
}
this.buildDayViewGrid();
this.previousMonthSelect.emit();
}
/**
* Method that selects next month
* Triggered only when the month is changed during changing focus
* Also triggers event to parent calendar component and rebuilds day view grid
* @private
* @return {?}
*/
selectNextMonth() {
if (this.currentlyDisplayed.month > 1) {
this.currentlyDisplayed = Object.assign({}, this.currentlyDisplayed, { month: this.currentlyDisplayed.month + 1 });
}
else {
this.currentlyDisplayed = { year: this.currentlyDisplayed.year + 1, month: 1 };
}
this.buildDayViewGrid();
this.nextMonthSelect.emit();
}
/**
* Method that creates array of CalendarDay models which will be shown on day grid,
* depending on current month and year.
* @private
* @return {?}
*/
populateCalendar() {
/** @type {?} */
let calendar = [];
calendar = this.getPreviousMonthDays(calendar);
calendar = calendar.concat(this.getCurrentMonthDays());
calendar = this.getNextMonthDays(calendar);
calendar.forEach((/**
* @param {?} call
* @param {?} index
* @return {?}
*/
(call, index) => call.id = this.id + '-fd-day-' + (Math.floor(index / 7) + 1) + '' + (index % 7)));
return calendar;
}
/**
* Method that builds 2 dimensions day view grid, also sets up currently displayed month, or year,
* when there is not any.
* @private
* @return {?}
*/
buildDayViewGrid() {
if (!this.currentlyDisplayed) {
if (this.selectedDate) {
this.currentlyDisplayed = { month: this.selectedDate.month, year: this.selectedDate.year };
}
else {
this.currentlyDisplayed = { month: FdDate.getToday().month, year: FdDate.getToday().year };
}
}
/** @type {?} */
const calendarDays = this.populateCalendar();
/** @type {?} */
const dayViewGrid = [];
while (calendarDays.length > 0) {
dayViewGrid.push(calendarDays.splice(0, 7));
}
this.dayViewGrid = dayViewGrid;
return;
}
/**
* Method which provides array of CalendarDay, which contains every single day of currently shown month/year.
* @private
* @return {?}
*/
getCurrentMonthDays() {
/** @type {?} */
const month = this.currentlyDisplayed.month;
/** @type {?} */
const year = this.currentlyDisplayed.year;
/** @type {?} */
const calendarDays = [];
/** @type {?} */
const amountOfDaysInCurrentMonth = CalendarService.getDaysInMonth(month, year);
for (let dayNumber = 1; dayNumber <= amountOfDaysInCurrentMonth; dayNumber++) {
/** @type {?} */
const fdDate = new FdDate(year, month, dayNumber);
calendarDays.push(Object.assign({}, this.getDay(fdDate), { monthStatus: 'current', today: CalendarService.datesEqual(FdDate.getToday(), fdDate) }));
}
this.getActiveCell(calendarDays).isTabIndexed = true;
return calendarDays;
}
/**
* Method that returns active cell, which means:
* if there is any selected day, return selected day
* if there is no selected day, but there is today day, return today day
* if there is no today, or selected, return first one
* @private
* @param {?} calendarDays
* @return {?}
*/
getActiveCell(calendarDays) {
if (calendarDays.find((/**
* @param {?} cell
* @return {?}
*/
cell => cell.selected))) {
return calendarDays.find((/**
* @param {?} cell
* @return {?}
*/
cell => cell.selected));
}
else if (calendarDays.find((/**
* @param {?} cell
* @return {?}
*/
cell => cell.today))) {
return calendarDays.find((/**
* @param {?} cell
* @return {?}
*/
cell => cell.today));
}
else {
return calendarDays[0];
}
}
/**
* Method which provides array of CalendarDay, which contains last 0-6 days of previous month/year. Theses days
* fills the gap between starting startingDayOfWeek and first day of current month
* @private
* @param {?} calendarDays
* @return {?}
*/
getPreviousMonthDays(calendarDays) {
/** @type {?} */
const month = this.currentlyDisplayed.month > 1 ? this.currentlyDisplayed.month - 1 : 12;
/** @type {?} */
const year = this.currentlyDisplayed.month > 1 ? this.currentlyDisplayed.year : this.currentlyDisplayed.year - 1;
/** @type {?} */
const amountOfDaysInCurrentMonth = CalendarService.getDaysInMonth(month, year);
/** @type {?} */
const prevMonthLastDate = new FdDate(year, month, amountOfDaysInCurrentMonth);
/** @type {?} */
const prevMonthLastDay = amountOfDaysInCurrentMonth;
/** @type {?} */
let prevMonthLastWeekDay = prevMonthLastDate.getDay() - this.startingDayOfWeek;
/** Checking if there are some days cut by startingDayOfWeek option
* If yes, there is whole week added, to avoid hiding
*/
if (prevMonthLastWeekDay < 0) {
prevMonthLastWeekDay = prevMonthLastWeekDay + 7;
}
if (prevMonthLastWeekDay < 6) {
while (prevMonthLastWeekDay >= 0) {
/** @type {?} */
const prevMonthDay = prevMonthLastDay - prevMonthLastWeekDay;
/** @type {?} */
const fdDate = new FdDate(year, month, prevMonthDay);
calendarDays.push(Object.assign({}, this.getDay(fdDate), { monthStatus: 'previous' }));
prevMonthLastWeekDay--;
}
}
return calendarDays;
}
/**
* Method which provides array of CalendarDay, which contains first days of next month/year. Theses days
* fills the gap between last day of current day and end of 6-weeks calendar grid.
* @private
* @param {?} calendarDays
* @return {?}
*/
getNextMonthDays(calendarDays) {
/** @type {?} */
const month = this.currentlyDisplayed.month < 12 ? this.currentlyDisplayed.month + 1 : 1;
/** @type {?} */
const year = this.currentlyDisplayed.month < 12 ? this.currentlyDisplayed.year : this.currentlyDisplayed.year + 1;
// The calendar grid can have 6 (42 days) weeks
/** @type {?} */
const nextMonthDisplayedDays = 42 - calendarDays.length;
for (let nextD = 1; nextD <= nextMonthDisplayedDays; nextD++) {
/** @type {?} */
const fdDate = new FdDate(year, month, nextD);
calendarDays.push(Object.assign({}, this.getDay(fdDate), { monthStatus: 'next' }));
}
return calendarDays;
}
/**
* Method that generates whole day model basing on fdDate, disabling functions, block functions, and actually
* chosen range / single date.
* @private
* @param {?} fdDate
* @return {?}
*/
getDay(fdDate) {
/** @type {?} */
const day = {
date: fdDate,
weekDay: fdDate.getDay(),
disabled: this.disableFunction(fdDate),
blocked: this.blockFunction(fdDate),
selected: ((this.calType === 'single' && CalendarService.datesEqual(fdDate, this.selectedDate)) ||
(this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.start)) ||
(this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.end))),
selectedFirst: (this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.start)),
selectedLast: (this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.end)),
selectedRange: (this.selectedRangeDate && ((this.selectedRangeDate.start && (this.selectedRangeDate.start.getTimeStamp() < fdDate.getTimeStamp())) &&
(this.selectedRangeDate.end && (this.selectedRangeDate.end.getTimeStamp() > fdDate.getTimeStamp())))),
ariaLabel: this.calendarI18n.getDayAriaLabel(fdDate.toDate())
};
if (this.calType === 'range' && (this.selectCounter === 0 || this.selectCounter === 2)) {
if (this.disableRangeStartFunction && !day.disabled) {
day.disabled = this.disableRangeStartFunction(day.date);
}
if (this.blockRangeStartFunction && !day.blocked) {
day.blocked = this.blockRangeStartFunction(day.date);
}
}
else if (this.selectCounter === 1) {
if (this.disableRangeEndFunction && !day.disabled) {
day.disabled = this.disableRangeEndFunction(day.date);
}
if (this.blockRangeEndFunction && !day.blocked) {
day.blocked = this.blockRangeEndFunction(day.date);
}
}
return day;
}
/**
* Method that returns first letter of every weekday, basing on CalendarI18nDefault. Can be changed by user by
* providing other class which implements CalendarI18n
* @private
* @return {?}
*/
getShortWeekDays() {
return this.calendarI18n.getAllShortWeekdays()
.slice(this.startingDayOfWeek - 1)
.concat(this.calendarI18n.getAllShortWeekdays().slice(0, this.startingDayOfWeek - 1))
.map((/**
* @param {?} weekday
* @return {?}
*/
weekday => weekday[0].toLocaleUpperCase()));
}
}
CalendarDayViewComponent.decorators = [
{ type: Component, args: [{
selector: 'fd-calendar-day-view',
template: "<table class=\"fd-calendar__table\" role=\"grid\">\n <thead class=\"fd-calendar__group\">\n <tr class=\"fd-calendar__row\">\n <th class=\"fd-calendar__column-header\" *ngFor=\"let day of shortWeekDays\">\n <span class=\"fd-calendar__day-of-week\">{{day}}</span>\n </th>\n </tr>\n </thead>\n <tbody class=\"fd-calendar__group\">\n <tr class=\"fd-calendar__row\"\n *ngFor=\"let row of dayViewGrid; let rowIndex = index;\">\n\n <td class=\"fd-calendar__item\"\n role=\"gridcell\"\n [attr.aria-label]=\"cell.ariaLabel\"\n *ngFor=\"let cell of row; let cellIndex = index;\"\n [ngClass]=\"{\n 'fd-calendar__item--other-month': cell.monthStatus !== 'current',\n 'is-selected': cell.selected,\n 'is-selected-range-last': cell.selectedLast && !cell.selectedFirst,\n 'is-selected-range-first': cell.selectedFirst,\n 'is-selected-range': cell.selectedRange && !cell.selectedFirst && !cell.selectedLast,\n 'fd-calendar__item--current': cell.today,\n 'is-disabled': cell.disabled,\n 'is-blocked': cell.blocked\n }\"\n [attr.id]=\"cell.id\"\n [attr.tabindex]=\"cell.isTabIndexed ? 0 : -1\"\n (click)=\"selectDate(cell, $event)\"\n (keydown)=\"onKeydownDayHandler($event, cell, { x: cellIndex, y: rowIndex })\"\n >\n <span class=\"fd-calendar__text\" role=\"button\">{{cell.date.day}}</span>\n </td>\n </tr>\n </tbody>\n</table>\n",
encapsulation: ViewEncapsulation.None,
host: {
'[attr.id]': 'id + "-day-view"'
},
styles: [""]
}] }
];
/** @nocollapse */
CalendarDayViewComponent.ctorParameters = () => [
{ type: CalendarI18n },
{ type: ElementRef }
];
CalendarDayViewComponent.propDecorators = {
fdCalendarDateViewClass: [{ type: HostBinding, args: ['class.fd-calendar__dates',] }],
currentlyDisplayed: [{ type: Input }],
selectedDate: [{ type: Input }],
selectedRangeDate: [{ type: Input }],
startingDayOfWeek: [{ type: Input }],
calType: [{ type: Input }],
id: [{ type: Input }],
focusEscapeFunction: [{ type: Input }],
selectedRangeDateChange: [{ type: Output }],
nextMonthSelect: [{ type: Output }],
previousMonthSelect: [{ type: Output }],
selectedDateChange: [{ type: Output }],
disableFunction: [{ type: Input }],
disableRangeStartFunction: [{ type: Input }],
disableRangeEndFunction: [{ type: Input }],
blockRangeStartFunction: [{ type: Input }],
blockRangeEndFunction: [{ type: Input }],
blockFunction: [{ type: Input }]
};
if (false) {
/**
* @hidden
* @type {?}
*/
CalendarDayViewComponent.prototype.newFocusedDayId;
/**
* @hidden
* @type {?}
*/
CalendarDayViewComponent.prototype.shortWeekDays;
/**
* Actual day grid with previous/current/next month days
* @type {?}
*/
CalendarDayViewComponent.prototype.dayViewGrid;
/**
* An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)
* @type {?}
* @private
*/
CalendarDayViewComponent.prototype.onDestroy$;
/**
* @hidden
* @type {?}
*/
CalendarDayViewComponent.prototype.fdCalendarDateViewClass;
/**
* Currently displayed month and year for days
* @type {?}
*/
CalendarDayViewComponent.prototype.currentlyDisplayed;
/**
* The currently selected FdDate model in single mode.
* @type {?}
*/
CalendarDayViewComponent.prototype.selectedDate;
/**
* The currently selected FdDates model start and end in range mode.
* @type {?}
*/
CalendarDayViewComponent.prototype.selectedRangeDate;
/**
* The day of the week the calendar should start on. 1 represents Sunday, 2 is Monday, 3 is Tuesday, and so on.
* @type {?}
*/
CalendarDayViewComponent.prototype.startingDayOfWeek;
/**
* The type of calendar, 'single' for single date selection or 'range' for a range of dates.
* @type {?}
*/
CalendarDayViewComponent.prototype.calType;
/**
* Id of the calendar. If none is provided, one will be generated.
* @type {?}
*/
CalendarDayViewComponent.prototype.id;
/**
* Function that allows to specify which function would be called, when focus wants to escape
* @type {?}
*/
CalendarDayViewComponent.prototype.focusEscapeFunction;
/**
* Event emitted always, when model is changed in range mode
* @type {?}
*/
CalendarDayViewComponent.prototype.selectedRangeDateChange;
/**
* Event emitted always, when next month is selected, by focus
* @type {?}
*/
CalendarDayViewComponent.prototype.nextMonthSelect;
/**
* Event emitted always, when previous month is selected, by focus
* @type {?}
*/
CalendarDayViewComponent.prototype.previousMonthSelect;
/**
* Event emitted always, when model is changed in single mode
* @type {?}
*/
CalendarDayViewComponent.prototype.selectedDateChange;
/**
* Function used to disable certain dates in the calendar.
* \@param fdDate FdDate
* @type {?}
*/
CalendarDayViewComponent.prototype.disableFunction;
/**
* Function used to disable certain dates in the calendar for the range start selection.
* \@param fdDate FdDate
* @type {?}
*/
CalendarDayViewComponent.prototype.disableRangeStartFunction;
/**
* Function used to disable certain dates in the calendar for the range end selection.
* \@param fdDate FdDate
* @type {?}
*/
CalendarDayViewComponent.prototype.disableRangeEndFunction;
/**
* Function used to block certain dates in the calendar for the range start selection.
* \@param fdDate FdDate
* @type {?}
*/
CalendarDayViewComponent.prototype.blockRangeStartFunction;
/**
* Function used to block certain dates in the calendar for the range end selection.
* \@param fdDate FdDate
* @type {?}
*/
CalendarDayViewComponent.prototype.blockRangeEndFunction;
/**
* Function used to block certain dates in the calendar.
* \@param fdDate FdDate
* @type {?}
*/
CalendarDayViewComponent.prototype.blockFunction;
/**
* @type {?}
* @private
*/
CalendarDayViewComponent.prototype.calendarI18n;
/**
* @type {?}
* @private
*/
CalendarDayViewComponent.prototype.eRef;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-day-view.component.js","sourceRoot":"ng://fundamental-ngx/","sources":["lib/calendar/calendar-views/calendar-day-view/calendar-day-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewChecked,\n    Component,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    Input, OnChanges,\n    OnInit,\n    Output,\n    ViewEncapsulation\n} from '@angular/core';\nimport { CalendarI18n } from '../../i18n/calendar-i18n';\nimport { FdDate } from '../../models/fd-date';\nimport { CalendarCurrent } from '../../models/calendar-current';\nimport { CalendarType, DaysOfWeek } from '../../calendar.component';\nimport { CalendarDay } from '../../models/calendar-day';\nimport { CalendarService } from '../../calendar.service';\nimport { FdRangeDate } from '../../models/fd-range-date';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n/** Component representing the day view of the calendar. */\n@Component({\n    selector: 'fd-calendar-day-view',\n    templateUrl: './calendar-day-view.component.html',\n    styleUrls: ['./calendar-day-view.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    host: {\n        '[attr.id]': 'id + \"-day-view\"'\n    }\n})\nexport class CalendarDayViewComponent implements OnInit, AfterViewChecked, OnChanges {\n\n    /** @hidden */\n    newFocusedDayId: string = '';\n\n    /** @hidden */\n    shortWeekDays: string[];\n\n    /** Actual day grid with previous/current/next month days */\n    public dayViewGrid: CalendarDay[][];\n\n    /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */\n    private readonly onDestroy$: Subject<void> = new Subject<void>();\n\n    /** @hidden */\n    @HostBinding('class.fd-calendar__dates')\n    public fdCalendarDateViewClass: boolean = true;\n\n    /** Currently displayed month and year for days */\n    @Input()\n    public currentlyDisplayed: CalendarCurrent;\n\n    /** The currently selected FdDate model in single mode. */\n    @Input()\n    public selectedDate: FdDate;\n\n    /** The currently selected FdDates model start and end in range mode. */\n    @Input()\n    public selectedRangeDate: FdRangeDate;\n\n    /** The day of the week the calendar should start on. 1 represents Sunday, 2 is Monday, 3 is Tuesday, and so on. */\n    @Input()\n    public startingDayOfWeek: DaysOfWeek;\n\n    /** The type of calendar, 'single' for single date selection or 'range' for a range of dates. */\n    @Input()\n    calType: CalendarType = 'single';\n\n    /** Id of the calendar. If none is provided, one will be generated. */\n    @Input() id: string;\n\n    /** Function that allows to specify which function would be called, when focus wants to escape */\n    @Input()\n    focusEscapeFunction: Function;\n\n    /** Event emitted always, when model is changed in range mode */\n    @Output()\n    public readonly selectedRangeDateChange: EventEmitter<FdRangeDate> = new EventEmitter<FdRangeDate>();\n\n    /** Event emitted always, when next month is selected, by focus */\n    @Output()\n    public readonly nextMonthSelect: EventEmitter<void> = new EventEmitter<void>();\n\n    /** Event emitted always, when previous month is selected, by focus */\n    @Output()\n    public readonly previousMonthSelect: EventEmitter<void> = new EventEmitter<void>();\n\n    /** Event emitted always, when model is changed in single mode */\n    @Output()\n    public readonly selectedDateChange: EventEmitter<FdDate> = new EventEmitter<FdDate>();\n\n    /**\n     * Function used to disable certain dates in the calendar.\n     * @param fdDate FdDate\n     */\n    @Input()\n    disableFunction = function(fdDate: FdDate): boolean {\n        return false;\n    };\n\n    /**\n     * Function used to disable certain dates in the calendar for the range start selection.\n     * @param fdDate FdDate\n     */\n    @Input()\n    disableRangeStartFunction = function(fdDate: FdDate): boolean {\n        return false;\n    };\n\n    /**\n     * Function used to disable certain dates in the calendar for the range end selection.\n     * @param fdDate FdDate\n     */\n    @Input()\n    disableRangeEndFunction = function(fdDate: FdDate): boolean {\n        return false;\n    };\n\n    /**\n     * Function used to block certain dates in the calendar for the range start selection.\n     * @param fdDate FdDate\n     */\n    @Input()\n    blockRangeStartFunction = function(fdDate: FdDate): boolean {\n        return false;\n    };\n\n    /**\n     * Function used to block certain dates in the calendar for the range end selection.\n     * @param fdDate FdDate\n     */\n    @Input()\n    blockRangeEndFunction = function(fdDate: FdDate): boolean {\n        return false;\n    };\n\n    /**\n     * Function used to block certain dates in the calendar.\n     * @param fdDate FdDate\n     */\n    @Input()\n    blockFunction = function(fdDate: FdDate): boolean {\n        return false;\n    };\n\n    /** @hidden */\n    constructor(\n        private calendarI18n: CalendarI18n,\n        private eRef: ElementRef\n    ) {\n    }\n\n    /**\n     * Function for selecting a date on the calendar. Typically called when a date is clicked, but can also be called programmatically.\n     * @param day CalendarDay object to be selected.\n     */\n    selectDate(day: CalendarDay, event?: MouseEvent): void {\n        if (event) {\n            /**\n             * There are some problems with popup integration. After clicking inside day component, the popover closes.\n             */\n            event.stopPropagation();\n            event.preventDefault();\n            this.newFocusedDayId = day.id;\n            this.focusElement(this.newFocusedDayId);\n        }\n        if (!day.blocked && !day.disabled) {\n            if (this.calType === 'single') {\n                this.selectedDate = day.date;\n                this.selectedDateChange.emit(day.date);\n                this.buildDayViewGrid();\n            } else {\n                if (this.selectCounter === 0 || this.selectCounter === 2) {\n                    this.selectedRangeDate = { start: day.date, end: null };\n                    this.selectedRangeDateChange.emit(this.selectedRangeDate);\n                    this.buildDayViewGrid();\n                } else if (this.selectCounter === 1) {\n                    // Check if date picked is higher than already chosen, otherwise just first one\n                    if (this.selectedRangeDate.start.getTimeStamp() < day.date.getTimeStamp()) {\n                        this.selectedRangeDate = { start: this.selectedRangeDate.start, end: day.date };\n                    } else {\n                        this.selectedRangeDate = { start: day.date, end: null };\n                    }\n                    this.selectedRangeDateChange.emit(this.selectedRangeDate);\n                    this.buildDayViewGrid();\n                }\n\n            }\n        }\n    }\n\n    /** @hidden */\n    ngOnInit(): void {\n        this.buildDayViewGrid();\n        this.shortWeekDays = this.getShortWeekDays();\n        this.calendarI18n.i18nChange\n            .pipe(takeUntil(this.onDestroy$))\n            .subscribe(() => this.shortWeekDays = this.getShortWeekDays())\n        ;\n    }\n\n    /** @hidden\n     *  Amount of selected days\n     *  0, when none,\n     *  1, when only startDate, or endDate same as startDate,\n     *  2, when both\n     */\n    get selectCounter(): number {\n        if (!this.selectedRangeDate || !this.selectedRangeDate.start) {\n            return 0;\n        } else if (this.selectedRangeDate.start &&\n            (!this.selectedRangeDate.end ||\n                CalendarService.datesEqual(this.selectedRangeDate.start, this.selectedRangeDate.end)\n            )\n        ) {\n            return 1;\n        } else if (this.selectedRangeDate.start && this.selectedRangeDate.end) {\n            return 2;\n        }\n    }\n\n    /**\n     * @hidden\n     * Method that handles day cells keydown events,\n     * @param event KeyboardEvent\n     * @param cell CalendarDay\n     * @param grid with specified column and row as a x and y\n     */\n    onKeydownDayHandler(event, cell: CalendarDay, grid: { x: number, y: number }): void {\n        if (event.code === 'Tab' && !event.shiftKey) {\n            if (this.focusEscapeFunction) {\n                event.preventDefault();\n                this.focusEscapeFunction();\n            }\n        } else {\n            switch (event.code) {\n                case('Space'):\n                case('Enter'): {\n                    event.preventDefault();\n                    this.selectDate(cell);\n                    this.newFocusedDayId = cell.id;\n                    break;\n                }\n                case('ArrowUp'): {\n                    event.preventDefault();\n                    if (grid.y > 0) {\n                        this.newFocusedDayId = this.dayViewGrid[grid.y - 1][grid.x].id;\n                    } else {\n                        this.selectPreviousMonth();\n                        this.newFocusedDayId = this.dayViewGrid[this.dayViewGrid.length - 1][grid.x].id;\n                    }\n                    break;\n                }\n                case('ArrowDown'): {\n                    event.preventDefault();\n                    if (grid.y < this.dayViewGrid.length - 1) {\n                        this.newFocusedDayId = this.dayViewGrid[grid.y + 1][grid.x].id;\n                    } else {\n                        this.selectNextMonth();\n                        this.newFocusedDayId = this.dayViewGrid[0][grid.x].id;\n                    }\n                    break;\n                }\n                case('ArrowLeft'): {\n                    event.preventDefault();\n                    if (grid.x > 0) {\n                        this.newFocusedDayId = this.dayViewGrid[grid.y][grid.x - 1].id;\n                    } else if (grid.y > 0) {\n                        this.newFocusedDayId = this.dayViewGrid[grid.y - 1][this.dayViewGrid[0].length - 1].id;\n                    } else {\n                        this.selectPreviousMonth();\n                        this.newFocusedDayId =\n                            this.dayViewGrid[this.dayViewGrid.length - 1][this.dayViewGrid[0].length - 1].id\n                        ;\n                    }\n                    break;\n                }\n                case('ArrowRight'): {\n                    event.preventDefault();\n                    if (grid.x < this.dayViewGrid[0].length - 1) {\n                        this.newFocusedDayId = this.dayViewGrid[grid.y][grid.x + 1].id;\n                    } else if (grid.y < this.dayViewGrid.length - 1) {\n                        this.newFocusedDayId = this.dayViewGrid[grid.y + 1][0].id;\n                    } else {\n                        this.selectNextMonth();\n                        this.newFocusedDayId = this.dayViewGrid[0][0].id;\n                    }\n                    break;\n                }\n            }\n        }\n\n        if (this.newFocusedDayId) {\n            this.focusElement(this.newFocusedDayId);\n        }\n    }\n\n    /** @hidden */\n    public ngOnChanges(): void {\n        this.buildDayViewGrid();\n    }\n\n    /** @hidden */\n    ngAfterViewChecked(): void {\n        if (this.newFocusedDayId) {\n            this.focusElement(this.newFocusedDayId);\n            this.newFocusedDayId = null;\n        }\n    }\n\n    /** @hidden\n     *  Method that allow to focus elements inside this component\n     */\n    public focusElement(elementSelector): void {\n        const elementToFocus = this.eRef.nativeElement.querySelector('#' + elementSelector);\n        if (elementToFocus) {\n            elementToFocus.focus();\n        }\n    }\n\n    /** Active day means that with tabindex = 0, it's selected day or today or first day */\n    public focusActiveDay(): void {\n        this.newFocusedDayId = this.getActiveCell(\n            this.calendarDayList.filter(cell => cell.monthStatus === 'current')\n        ).id;\n    }\n\n    /** Function that gives array of all displayed CalendarDays */\n    public get calendarDayList(): CalendarDay[] {\n        return this.dayViewGrid.reduce((totalCalendarRows: CalendarDay[], calendarRow: CalendarDay[]) => {\n            if (!calendarRow) {\n                calendarRow = [];\n            }\n            return totalCalendarRows.concat(calendarRow);\n        });\n    }\n\n    /**\n     * Method that selects previous month\n     * Triggered only when the month is changed during changing focus\n     * Also triggers event to parent calendar component and rebuilds day view grid\n     */\n    private selectPreviousMonth(): void {\n        if (this.currentlyDisplayed.month > 1) {\n            this.currentlyDisplayed = { ...this.currentlyDisplayed, month: this.currentlyDisplayed.month - 1 };\n        } else {\n            this.currentlyDisplayed = { year: this.currentlyDisplayed.year - 1, month: 12 };\n        }\n        this.buildDayViewGrid();\n        this.previousMonthSelect.emit();\n    }\n\n    /**\n     * Method that selects next month\n     * Triggered only when the month is changed during changing focus\n     * Also triggers event to parent calendar component and rebuilds day view grid\n     */\n    private selectNextMonth(): void {\n        if (this.currentlyDisplayed.month > 1) {\n            this.currentlyDisplayed = { ...this.currentlyDisplayed, month: this.currentlyDisplayed.month + 1 };\n        } else {\n            this.currentlyDisplayed = { year: this.currentlyDisplayed.year + 1, month: 1 };\n        }\n        this.buildDayViewGrid();\n        this.nextMonthSelect.emit();\n    }\n\n    /**\n     * Method that creates array of CalendarDay models which will be shown on day grid,\n     * depending on current month and year.\n     */\n    private populateCalendar(): CalendarDay[] {\n        let calendar: CalendarDay[] = [];\n\n        calendar = this.getPreviousMonthDays(calendar);\n        calendar = calendar.concat(this.getCurrentMonthDays());\n        calendar = this.getNextMonthDays(calendar);\n\n        calendar.forEach((call, index: number) => call.id = this.id + '-fd-day-' + (Math.floor(index / 7) + 1) + '' + (index % 7));\n\n        return calendar;\n    }\n\n    /**\n     * Method that builds 2 dimensions day view grid, also sets up currently displayed month, or year,\n     * when there is not any.\n     */\n    private buildDayViewGrid(): void {\n        if (!this.currentlyDisplayed) {\n            if (this.selectedDate) {\n                this.currentlyDisplayed = { month: this.selectedDate.month, year: this.selectedDate.year };\n            } else {\n                this.currentlyDisplayed = { month: FdDate.getToday().month, year: FdDate.getToday().year };\n            }\n        }\n\n        const calendarDays = this.populateCalendar();\n        const dayViewGrid: CalendarDay[][] = [];\n\n        while (calendarDays.length > 0) {\n            dayViewGrid.push(calendarDays.splice(0, 7));\n        }\n        this.dayViewGrid = dayViewGrid;\n        return;\n    }\n\n    /**\n     * Method which provides array of CalendarDay, which contains every single day of currently shown month/year.\n     */\n    private getCurrentMonthDays(): CalendarDay[] {\n        const month = this.currentlyDisplayed.month;\n        const year = this.currentlyDisplayed.year;\n        const calendarDays: CalendarDay[] = [];\n        const amountOfDaysInCurrentMonth: number = CalendarService.getDaysInMonth(month, year);\n        for (let dayNumber = 1; dayNumber <= amountOfDaysInCurrentMonth; dayNumber++) {\n            const fdDate: FdDate = new FdDate(year, month, dayNumber);\n            calendarDays.push({\n                ...this.getDay(fdDate),\n                monthStatus: 'current',\n                today: CalendarService.datesEqual(FdDate.getToday(), fdDate)\n            });\n        }\n        this.getActiveCell(calendarDays).isTabIndexed = true;\n        return calendarDays;\n    }\n\n    /**\n     * Method that returns active cell, which means:\n     * if there is any selected day, return selected day\n     * if there is no selected day, but there is today day, return today day\n     * if there is no today, or selected, return first one\n     */\n    private getActiveCell(calendarDays: CalendarDay[]): CalendarDay {\n        if (calendarDays.find(cell => cell.selected)) {\n            return calendarDays.find(cell => cell.selected);\n        } else if (calendarDays.find(cell => cell.today)) {\n            return calendarDays.find(cell => cell.today);\n        } else {\n            return calendarDays[0];\n        }\n    }\n\n    /**\n     * Method which provides array of CalendarDay, which contains last 0-6 days of previous month/year. Theses days\n     * fills the gap between starting startingDayOfWeek and first day of current month\n     */\n    private getPreviousMonthDays(calendarDays: CalendarDay[]): CalendarDay[] {\n        const month = this.currentlyDisplayed.month > 1 ? this.currentlyDisplayed.month - 1 : 12;\n        const year = this.currentlyDisplayed.month > 1 ? this.currentlyDisplayed.year : this.currentlyDisplayed.year - 1;\n        const amountOfDaysInCurrentMonth: number = CalendarService.getDaysInMonth(month, year);\n        const prevMonthLastDate = new FdDate(year, month, amountOfDaysInCurrentMonth);\n        const prevMonthLastDay = amountOfDaysInCurrentMonth;\n        let prevMonthLastWeekDay = prevMonthLastDate.getDay() - this.startingDayOfWeek;\n\n        /** Checking if there are some days cut by startingDayOfWeek option\n         *  If yes, there is whole week added, to avoid hiding\n         */\n        if (prevMonthLastWeekDay < 0) {\n            prevMonthLastWeekDay = prevMonthLastWeekDay + 7;\n        }\n\n        if (prevMonthLastWeekDay < 6) {\n            while (prevMonthLastWeekDay >= 0) {\n                const prevMonthDay = prevMonthLastDay - prevMonthLastWeekDay;\n                const fdDate = new FdDate(year, month, prevMonthDay);\n                calendarDays.push({ ...this.getDay(fdDate), monthStatus: 'previous' });\n                prevMonthLastWeekDay--;\n            }\n        }\n        return calendarDays;\n    }\n\n    /**\n     * Method which provides array of CalendarDay, which contains first days of next month/year. Theses days\n     * fills the gap between last day of current day and end of 6-weeks calendar grid.\n     */\n    private getNextMonthDays(calendarDays: CalendarDay[]): CalendarDay[] {\n        const month = this.currentlyDisplayed.month < 12 ? this.currentlyDisplayed.month + 1 : 1;\n        const year = this.currentlyDisplayed.month < 12 ? this.currentlyDisplayed.year : this.currentlyDisplayed.year + 1;\n\n        // The calendar grid can have 6 (42 days) weeks\n        const nextMonthDisplayedDays = 42 - calendarDays.length;\n\n        for (let nextD = 1; nextD <= nextMonthDisplayedDays; nextD++) {\n            const fdDate = new FdDate(year, month, nextD);\n            calendarDays.push({ ...this.getDay(fdDate), monthStatus: 'next' });\n        }\n        return calendarDays;\n    }\n\n    /**\n     * Method that generates whole day model basing on fdDate, disabling functions, block functions, and actually\n     * chosen range / single date.\n     */\n    private getDay(fdDate: FdDate): CalendarDay {\n        const day: CalendarDay = {\n            date: fdDate,\n            weekDay: fdDate.getDay(),\n            disabled: this.disableFunction(fdDate),\n            blocked: this.blockFunction(fdDate),\n            selected: (\n                (this.calType === 'single' && CalendarService.datesEqual(fdDate, this.selectedDate)) ||\n                (this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.start)) ||\n                (this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.end))\n            ),\n            selectedFirst: (this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.start)),\n            selectedLast: (this.selectedRangeDate && CalendarService.datesEqual(fdDate, this.selectedRangeDate.end)),\n            selectedRange: (this.selectedRangeDate && (\n                (this.selectedRangeDate.start && (this.selectedRangeDate.start.getTimeStamp() < fdDate.getTimeStamp())) &&\n                (this.selectedRangeDate.end && (this.selectedRangeDate.end.getTimeStamp() > fdDate.getTimeStamp()))\n            )),\n            ariaLabel: this.calendarI18n.getDayAriaLabel(fdDate.toDate())\n        };\n\n        if (this.calType === 'range' && (this.selectCounter === 0 || this.selectCounter === 2)) {\n            if (this.disableRangeStartFunction && !day.disabled) {\n                day.disabled = this.disableRangeStartFunction(day.date);\n            }\n            if (this.blockRangeStartFunction && !day.blocked) {\n                day.blocked = this.blockRangeStartFunction(day.date);\n            }\n        } else if (this.selectCounter === 1) {\n            if (this.disableRangeEndFunction && !day.disabled) {\n                day.disabled = this.disableRangeEndFunction(day.date);\n            }\n\n            if (this.blockRangeEndFunction && !day.blocked) {\n                day.blocked = this.blockRangeEndFunction(day.date);\n            }\n        }\n\n        return day;\n    }\n\n    /**\n     * Method that returns first letter of every weekday, basing on CalendarI18nDefault. Can be changed by user by\n     * providing other class which implements CalendarI18n\n     */\n    private getShortWeekDays(): string[] {\n        return this.calendarI18n.getAllShortWeekdays()\n            .slice(this.startingDayOfWeek - 1)\n            .concat(this.calendarI18n.getAllShortWeekdays().slice(0, this.startingDayOfWeek - 1))\n            .map(weekday => weekday[0].toLocaleUpperCase());\n    }\n}\n"]}