@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/input/calendar/esm2022/calendar.component.mjs

@@ -0,0 +1,637 @@
+import { Component, ElementRef, Inject, Injector, Optional, ViewChild, ViewEncapsulation } from '@angular/core';
+import { AbstractI18nService, getClonedObject, getSessionStorageItem, isMobile } from '@wm/core';
+import { APPLY_STYLES_TYPE, createArrayFrom, getEvaluatedData, provideAsWidgetRef, StylableComponent, styler } from '@wm/components/base';
+import { registerProps } from './calendar.props';
+import { capitalize, clone, each, extend, get, includes, isDate, isEmpty, isObject, mapKeys } from "lodash-es";
+import * as momentLib from 'moment';
+import { Calendar } from '@fullcalendar/core';
+import dayGridPlugin from '@fullcalendar/daygrid';
+import timeGridPlugin from '@fullcalendar/timegrid';
+import listPlugin from '@fullcalendar/list';
+import interactionPlugin from '@fullcalendar/interaction';
+import allLocales from '@fullcalendar/core/locales-all';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+const moment = momentLib.default || window['moment'];
+const DEFAULT_CLS = 'app-calendar';
+const dateFormats = ['yyyy-MM-dd', 'yyyy-M-dd', 'M-dd-yyyy', 'MM-dd-yy', 'yyyy, dd MMMM', 'yyyy, MMM dd', 'MM/dd/yyyy', 'M/d/yyyy', 'EEE, dd MMM yyyy', 'EEE MMM dd yyyy', 'EEEE, MMMM dd, yyyy', 'timestamp'];
+const defaultHeaderOptions = {
+    start: 'prev next today',
+    center: 'title',
+    end: 'dayGridMonth dayGridWeek dayGridDay'
+};
+const VIEW_TYPES = {
+    BASIC: 'basic',
+    AGENDA: 'agenda',
+    LIST: 'list'
+};
+const BUTTON_TEXT = {
+    YEAR: 'Year',
+    MONTH: 'Month',
+    WEEK: 'Week',
+    DAY: 'Day',
+    TODAY: 'Today'
+};
+const SELECTION_MODES = {
+    NONE: 'none',
+    SINGLE: 'single',
+    MULTIPLE: 'multiple'
+};
+const NEXT_DAY_THRESHOLD = {
+    START: '00:00',
+    END: '24:00'
+};
+const getEventMomentValue = (value, key) => {
+    let isDate = false;
+    dateFormats.forEach((format) => {
+        // moment supports uppercase formats
+        if (moment(value, format.toUpperCase(), true).isValid()) {
+            isDate = true;
+            return false;
+        }
+    });
+    // if the value is date then for end date the value should be end of the day as the calendar is approximating it to the start.
+    if (isDate && key === 'end') {
+        return moment(value).endOf('day');
+    }
+    return moment(value);
+};
+const getUTCDateTime = (dateObj) => {
+    dateObj = moment(dateObj);
+    const year = dateObj.format('YYYY'), 
+    // javascript starts the month count from '0' where as moment returns the human count
+    month = dateObj.format('MM') - 1, day = dateObj.format('DD'), hours = dateObj.format('HH'), minutes = dateObj.format('mm'), seconds = dateObj.format('ss');
+    return new Date(year, month, day, hours, minutes, seconds);
+};
+const WIDGET_CONFIG = { widgetType: 'wm-calendar', hostClass: DEFAULT_CLS };
+const dateFormat = 'YYYY/MM/DD';
+export class CalendarComponent extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    // this function selects the default date given for the calendar
+    selectDate() {
+        let start, end;
+        // checks if datavalue is an object and not a Date object
+        if (isObject(this.datavalue) && !isDate(this.datavalue)) {
+            // @ts-ignore
+            start = moment(this.datavalue.start);
+            // @ts-ignore
+            end = moment(this.datavalue.end);
+        }
+        else {
+            start = moment(this.datavalue);
+            end = moment(this.datavalue).add(1, 'day').startOf('day');
+        }
+        this.$fullCalendar.gotoDate(moment(start)._d); // after selecting the date go to the date.
+        this.$fullCalendar.select(start.valueOf(), end.valueOf());
+    }
+    // changes the calendar view to the default date given for the calendar.
+    gotoDate() {
+        this.$fullCalendar.gotoDate(moment(this.datavalue)._d);
+    }
+    // this function takes the calendar view to the a year ahead
+    gotoNextYear() {
+        this.$fullCalendar.nextYear();
+    }
+    // this function takes the calendar view to the a year before
+    gotoPrevYear() {
+        this.$fullCalendar.prevYear();
+    }
+    /**
+     * this function takes the calendar view to the specified month
+     * @param monthVal, 1-12 value of month
+     */
+    gotoMonth(monthVal) {
+        let presentDay = this.$fullCalendar.getDate();
+        const presentMonthVal = presentDay.getMonth();
+        presentDay = moment(presentDay);
+        if (presentMonthVal < monthVal) {
+            this.$fullCalendar.gotoDate(presentDay.add(monthVal - presentMonthVal - 1, 'M').valueOf());
+        }
+        else {
+            this.$fullCalendar.gotoDate(presentDay.subtract(presentMonthVal - monthVal + 1, 'M').valueOf());
+        }
+    }
+    // this function takes the calendar view to the a month ahead
+    gotoNextMonth() {
+        const presentDay = moment(this.$fullCalendar.getDate());
+        this.$fullCalendar.gotoDate(presentDay.add(1, 'M').valueOf());
+    }
+    // this function takes the calendar view to the a month before
+    gotoPrevMonth() {
+        const presentDay = moment(this.$fullCalendar.getDate());
+        this.$fullCalendar.gotoDate(presentDay.subtract(1, 'M').valueOf());
+    }
+    // this function re-renders the events assigned to the calendar.
+    rerenderEvents() {
+        this.$fullCalendar.render();
+    }
+    setSelectedData(start, end) {
+        let dataset = this.dataset;
+        if (!dataset) {
+            return;
+        }
+        const filteredDates = [];
+        const eventStartKey = this.eventstart || 'start';
+        const eventEndKey = this.eventend || 'end';
+        const startDate = moment(new Date(start)).format('MM/DD/YYYY');
+        const endDate = moment(new Date(end)).subtract(1, 'days').format('MM/DD/YYYY');
+        dataset = dataset.data || dataset;
+        dataset.forEach((value) => {
+            if (!value[eventStartKey]) {
+                return;
+            }
+            const eventStartDate = moment(new Date(value[eventStartKey])).format('MM/DD/YYYY');
+            const eventEndDate = moment(new Date(value[eventEndKey] || value[eventStartKey])).format('MM/DD/YYYY');
+            const eventExists = moment(eventStartDate).isSameOrAfter(startDate) && moment(eventEndDate).isSameOrBefore(endDate);
+            if (eventExists) {
+                filteredDates.push(value);
+            }
+        });
+        return filteredDates;
+    }
+    eventDrop(eventDropInfo) {
+        let newDataObj = this.convertEventObjForOldAndNewData(eventDropInfo.event);
+        let oldDataObj = this.convertEventObjForOldAndNewData(eventDropInfo.oldEvent);
+        this.invokeEventCallback('eventdrop', { $event: eventDropInfo.jsEvent, $newData: newDataObj, $oldData: oldDataObj, $delta: eventDropInfo.delta, $revertFunc: eventDropInfo.revert, $ui: {}, $view: eventDropInfo.view });
+    }
+    // Returns the default date when the datavalue is provided
+    getDefaultDate() {
+        if (this.datavalue) {
+            return new Date(this.datavalue);
+        }
+    }
+    getDefaultOptions() {
+        return this.calendarOptions;
+    }
+    getLib() {
+        return 'fullcalendar';
+    }
+    select($selectionInfo) {
+        this.selecteddates = { start: getUTCDateTime($selectionInfo.start), end: getUTCDateTime($selectionInfo.end) };
+        this.selecteddata = this.setSelectedData($selectionInfo.start, $selectionInfo.end);
+        this.invokeEventCallback('select', { $start: $selectionInfo.start.valueOf(), $end: $selectionInfo.end.valueOf(), $view: $selectionInfo.view, $data: this.selecteddata });
+    }
+    /**
+     *  this functions unselects all the selections in calendar
+     */
+    unselect() {
+        this.$fullCalendar.unselect();
+    }
+    /**
+     * this function is to add extendedProps data to the data object.
+     * this is done for backward compatibility
+     * @param eventObj event object as per new version (v5)
+     * @returns _eventMetadata event object as per the old version (v3)
+     */
+    convertEventObj(eventObj) {
+        if (!eventObj.extendedProps._eventMetadata) {
+            return eventObj;
+        }
+        const _eventMetadata = eventObj.extendedProps._eventMetadata;
+        Object.setPrototypeOf(_eventMetadata, eventObj);
+        return _eventMetadata;
+    }
+    /**
+     *  this function is to add extendedProps data to the data object exluding start end title allDay objects if the key name matches.
+     * * this is done for backward compatibility
+     * @param eventObj event object as per new version (v5)
+     * @returns data event object as per the old version (v3)
+     */
+    convertEventObjForOldAndNewData(eventObj) {
+        const _eventMetadata = eventObj.extendedProps;
+        extend(eventObj, _eventMetadata);
+        return eventObj;
+    }
+    eventResize(eventResizeInfo) {
+        let newDataObj = this.convertEventObjForOldAndNewData(eventResizeInfo.event);
+        let oldDataObj = this.convertEventObjForOldAndNewData(eventResizeInfo.oldEvent);
+        this.invokeEventCallback('eventresize', { $event: eventResizeInfo.jsEvent, $newData: newDataObj, $oldData: oldDataObj, $delta: eventResizeInfo.delta, $revertFunc: eventResizeInfo.revert, $ui: {}, $view: eventResizeInfo.view });
+    }
+    onEventChangeStart(event) {
+        this.oldData = getClonedObject(event);
+    }
+    eventClick(eventClickInfo) {
+        let eventObj = this.convertEventObj(eventClickInfo.event);
+        this.invokeEventCallback('eventclick', { $event: eventClickInfo.jsEvent, $data: eventObj, $view: eventClickInfo.view });
+    }
+    eventDidMount(event) {
+        let eventObj = this.convertEventObj(event.event);
+        if (this.calendartype === VIEW_TYPES.LIST) {
+            this.$element.find('.fc-list-table').addClass('table');
+        }
+        this.invokeEventCallback('eventrender', { $event: event.el, $data: eventObj, $view: event.view });
+    }
+    viewDidMount($view) {
+        if (this.calendartype === VIEW_TYPES.LIST) {
+            this.$element.find('.fc-list-table').addClass('table');
+        }
+        this.invokeEventCallback('viewrender', { $view: $view });
+    }
+    /**
+     * This function gets called when the view of the calendar changes.
+     * @param data contains the start end data of the calendar view.
+     */
+    datesSet(data) {
+        this.currentview = { start: moment(data.start).format("YYYY-MM-DD"), end: moment(data.end).format("YYYY-MM-DD") };
+    }
+    dateClick($info) {
+        const dateInfo = getUTCDateTime($info.date).valueOf();
+        this.invokeEventCallback('dateclick', { $dateInfo: dateInfo });
+    }
+    // update the calendar header options once the controls changes
+    updateCalendarHeaderOptions() {
+        const ctrls = this.controls, viewType = this.calendartype, regEx = new RegExp('\\bday\\b', 'g');
+        let left = '', right = '';
+        if (ctrls && viewType) {
+            if (includes(ctrls, 'navigation')) {
+                left += ' prev next';
+            }
+            if (includes(ctrls, 'today')) {
+                left += ' today';
+            }
+            if (includes(ctrls, 'year')) {
+                right += (viewType === VIEW_TYPES.LIST) ? 'listYear' : '';
+            }
+            if (includes(ctrls, 'month')) {
+                right += (viewType === VIEW_TYPES.LIST) ? ' listMonth' : ' dayGridMonth';
+            }
+            if (includes(ctrls, 'week')) {
+                right += (viewType === VIEW_TYPES.BASIC) ? ' dayGridWeek' : (viewType === VIEW_TYPES.LIST) ? ' listWeek' : ' timeGridWeek';
+            }
+            if (regEx.test(ctrls)) {
+                right += (viewType === VIEW_TYPES.BASIC) ? ' dayGridDay' : (viewType === VIEW_TYPES.LIST) ? ' listDay' : ' timeGridDay';
+            }
+            if (left.charAt(0) === ' ') {
+                left = left.substring(1);
+            }
+            if (right.charAt(0) === ' ') {
+                right = right.substring(1);
+            }
+            extend(this.calendarOptions.calendar.headerToolbar, { 'start': left, 'end': right });
+        }
+    }
+    constructor(inj, i18nService, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        this.controls = 'navigation, today, year, month, week, day';
+        this.eventSources = [];
+        this.dataSetEvents = {
+            events: []
+        };
+        this.changesStack = [];
+        // calendarOptions to the calendar
+        this.calendarOptions = {
+            calendar: {
+                height: 600,
+                eventSources: this.eventSources,
+                editable: true,
+                locale: getSessionStorageItem('selectedLocale') || 'en',
+                selectable: false,
+                longPressDelay: isMobile() ? 1 : 1000,
+                headerToolbar: defaultHeaderOptions,
+                nextDayThreshold: NEXT_DAY_THRESHOLD,
+                views: {
+                    month: {
+                        dayMaxEventsRow: true
+                    }
+                },
+                unselectAuto: false,
+                eventDrop: this.eventDrop.bind(this),
+                eventResizeStart: this.onEventChangeStart.bind(this),
+                eventDragStart: this.onEventChangeStart.bind(this),
+                eventResize: this.eventResize.bind(this),
+                eventClick: this.eventClick.bind(this),
+                select: this.select.bind(this),
+                eventDidMount: this.eventDidMount.bind(this),
+                viewDidMount: this.viewDidMount.bind(this),
+                datesSet: this.datesSet.bind(this),
+                dateClick: this.dateClick.bind(this)
+            }
+        };
+        this.dayClass = [];
+        this.eventSources.push(this.dataSetEvents);
+        let FullCalendar = window['FullCalendar'] ? window['FullCalendar'] : Calendar;
+        if (!FullCalendar.__wm_locale_initialized) {
+            i18nService.initCalendarLocale();
+            FullCalendar.__wm_locale_initialized = true;
+        }
+        this.cancelLocaleChangeSubscription = this.getAppInstance().subscribe("locale-changed", (libLocale) => {
+            this.setLocale();
+            this.applyCalendarOptions('option', 'locale', libLocale.fullCalendar || 'en');
+            this.redraw();
+        });
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        styler(this.nativeElement, this, APPLY_STYLES_TYPE.CONTAINER, ['height']);
+        this.setLocale();
+    }
+    onStyleChange(key, nv, ov) {
+        super.onStyleChange(key, nv, ov);
+        if (key === 'height') {
+            this.calendarOptions.calendar.height = this.calculateHeight(nv);
+            this.updateCalendarOptions('option', 'height', this.calendarOptions.calendar.height);
+        }
+    }
+    onPropertyChange(key, nv, ov) {
+        super.onPropertyChange(key, nv, ov);
+        switch (key) {
+            case 'selectionmode':
+                if (nv !== SELECTION_MODES.NONE) {
+                    this.calendarOptions.calendar.selectable = true;
+                    this.updateCalendarOptions('option', 'selectable', true);
+                    if (nv === SELECTION_MODES.SINGLE) {
+                        this.calendarOptions.calendar.selectConstraint = {
+                            startTime: '00:00',
+                            endTime: '24:00'
+                        };
+                        this.updateCalendarOptions('option', 'selectConstraint', this.calendarOptions.calendar.selectConstraint);
+                    }
+                    else {
+                        this.updateCalendarOptions('option', 'selectConstraint', {});
+                    }
+                }
+                else {
+                    this.calendarOptions.calendar.selectable = false;
+                    this.updateCalendarOptions('option', 'selectable', false);
+                }
+                break;
+            case 'view':
+                if (nv !== 'month' || this.calendartype === VIEW_TYPES.LIST) {
+                    this.calendarOptions.calendar.defaultView = this.calendartype + capitalize(nv);
+                }
+                else {
+                    this.calendarOptions.calendar.defaultView = nv;
+                }
+                this.updateCalendarOptions('changeView', this.calendarOptions.calendar.defaultView);
+                break;
+            case 'calendartype':
+                this.calendartype = nv || 'dayGrid';
+            case 'controls':
+                this.updateCalendarHeaderOptions();
+                break;
+            case 'dataset':
+                let dataSet;
+                const self = this;
+                this.dataset = nv;
+                dataSet = createArrayFrom(getClonedObject(nv));
+                dataSet = this.constructCalendarDataset(dataSet);
+                this.dataSetEvents.events = dataSet.filter((event) => {
+                    event.start = event.start || event.end;
+                    if (event.start) {
+                        return true;
+                    }
+                });
+                this.renderEventDataSet();
+                break;
+            case 'show':
+                this.$fullCalendar?.changeView(this.getViewType(this.view ? this.view : 'dayGridMonth'));
+        }
+    }
+    // to calculate the height for the event limit and parsing the value when it is percentage based.
+    calculateHeight(height) {
+        const $parent = $(this.nativeElement).parent(), elHeight = height || '650px';
+        let parentHeight = $parent.css('height'), computedHeight;
+        if (includes(elHeight, '%')) {
+            if (includes(parentHeight, '%')) {
+                parentHeight = $parent.height();
+            }
+            computedHeight = (parseInt(parentHeight, 10) * Number(elHeight.replace(/\%/g, ''))) / 100;
+        }
+        else {
+            computedHeight = parseInt(elHeight, 10);
+        }
+        this.calendarOptions.calendar.views.month.eventLimit = parseInt('' + computedHeight / 200, 10) + 1;
+        return computedHeight;
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        const calendarEl = this._calendar.nativeElement;
+        let FullCalendar;
+        if (window['FullCalendar'])
+            FullCalendar = window['FullCalendar'].Calendar;
+        else {
+            FullCalendar = Calendar;
+            this.calendarOptions.calendar = { ...this.calendarOptions.calendar, plugins: [dayGridPlugin, timeGridPlugin, listPlugin, listPlugin, interactionPlugin], locales: allLocales };
+        }
+        const calendar = new FullCalendar(calendarEl, this.calendarOptions.calendar);
+        this.$fullCalendar = calendar;
+        this.invokeEventCallback('beforerender', { '$event': {} });
+        calendar.render();
+        // if the changes are already stacked before calendar renders then execute them when needed
+        if (this.changesStack.length) {
+            this.changesStack.forEach((changeObj) => {
+                this.applyCalendarOptions(changeObj.operationType, changeObj.argumentKey, changeObj.argumentValue);
+            });
+            this.changesStack.length = 0;
+        }
+        $(".fc-prev-button").attr("aria-label", "prev");
+        $(".fc-next-button").attr("aria-label", "next");
+        $(".fc-today-button").attr("aria-label", "today");
+        //WMS-22412 : change calender's view based on the configuration set from studio
+        setTimeout(() => {
+            this.$fullCalendar.changeView(this.getViewType(this.view ? this.view : 'dayGridMonth'));
+        }, 50);
+    }
+    // constructs the calendar dataset by mapping the eventstart, eventend, eventtitle etc.,
+    constructCalendarDataset(eventSource) {
+        const properties = {
+            title: this.eventtitle || 'title',
+            allDay: this.eventallday || 'allday',
+            start: this.eventstart || 'start',
+            end: this.eventend || 'end',
+            className: this.eventclass || 'className'
+        };
+        eventSource.forEach((obj) => {
+            obj._eventMetadata = clone(obj);
+            if (isEmpty(obj._eventMetadata.url)) {
+                delete obj._eventMetadata.url;
+            }
+            if (isEmpty(obj.url)) {
+                delete obj.url;
+            }
+            mapKeys(properties, (value, key) => {
+                let objVal;
+                if (key === 'title') {
+                    objVal = getEvaluatedData(obj, { expression: value }, this.viewParent);
+                }
+                else if (key === 'allDay') {
+                    objVal = !!get(obj, value);
+                }
+                else {
+                    objVal = get(obj, value);
+                }
+                if (!objVal) {
+                    return;
+                }
+                obj[key] = objVal;
+            });
+        });
+        return eventSource;
+    }
+    setLocale() {
+        const year = get(this.appLocale, 'LABEL_CALENDAR_YEAR') || BUTTON_TEXT.YEAR;
+        const month = get(this.appLocale, 'LABEL_CALENDAR_MONTH') || BUTTON_TEXT.MONTH;
+        const week = get(this.appLocale, 'LABEL_CALENDAR_WEEK') || BUTTON_TEXT.WEEK;
+        const day = get(this.appLocale, 'LABEL_CALENDAR_DAY') || BUTTON_TEXT.DAY;
+        const today = get(this.appLocale, 'LABEL_CALENDAR_TODAY') || BUTTON_TEXT.TODAY;
+        this.calendarOptions.calendar.buttonText = { year, month, week, day, today,
+            'listYear': year,
+            'listMonth': month,
+            'listWeek': week,
+            'listDay': day
+        };
+    }
+    /**
+     * override the default calendar options with the newSet of options
+     * @param options
+     */
+    overrideDefaults(options) {
+        if (isObject(options)) {
+            Object.entries(options).map(option => this.$fullCalendar.setOption(option[0], option[1]));
+        }
+    }
+    /**
+     * if the operations are performed before the calendar renders, the changes are pushed into changesStack and will be executed after the calendar gets rendered
+     * if the calendar is already rendered, then the specific operation will be performed according to the operation type
+     * @param operationType
+     * @param argumentKey
+     * @param argumentValue
+     */
+    updateCalendarOptions(operationType, argumentKey, argumentValue) {
+        if (!this.$fullCalendar) {
+            this.changesStack.push({
+                operationType: operationType,
+                argumentKey: argumentKey,
+                argumentValue: argumentValue
+            });
+            return;
+        }
+        this.applyCalendarOptions(operationType, argumentKey, argumentValue);
+    }
+    redraw() {
+        this.updateCalendarOptions('render');
+        this.$fullCalendar?.changeView(this.getViewType(this.view ? this.view : 'dayGridMonth'));
+    }
+    // on date change invoke the select event, and if date has event on it then invoke the event click.
+    onValueChange(value) {
+        this.proxyModel = value;
+        const selectedDate = this.proxyModel && moment(this.proxyModel).startOf('day').format(dateFormat), selectedEventData = this.eventData[selectedDate], start = moment(this.proxyModel), end = moment(this.proxyModel).endOf('day');
+        this.selecteddata = selectedEventData;
+        this.selecteddates = {
+            'start': moment(selectedDate).valueOf(),
+            'end': moment(selectedDate).endOf('day').valueOf()
+        };
+        this.calendarOptions.calendar.select(start.valueOf(), end.valueOf(), {}, this, selectedEventData);
+        if (selectedEventData) {
+            this.calendarOptions.calendar.eventClick(selectedEventData, {}, this);
+        }
+    }
+    /**
+     * This function will receive an object containing source of calendar, apikey and calendarId and will integrate the respective calendar with fullcalendar.
+     * @param eventObject
+     */
+    addEventSource(eventObject) {
+        if (isEmpty(eventObject)) {
+            console.warn('addEventSource method requires an object as a parameter.');
+            return;
+        }
+        if (eventObject.source === 'google') {
+            if (!eventObject.googleCalendarApiKey || !eventObject.googleCalendarId) {
+                console.warn('For google calendar integration, \'googleCalendarApiKey\' and \'googleCalendarId\' should be passed in the parameter object.');
+                return;
+            }
+            this.$fullCalendar.setOption('googleCalendarApiKey', eventObject.googleCalendarApiKey);
+            this.$fullCalendar.addEventSource({
+                googleCalendarId: eventObject.googleCalendarId
+            });
+        }
+    }
+    /**
+     * get the viewTypeKey according to the calendarType and viewType selected
+     * @param viewKey
+     */
+    getViewType(viewKey) {
+        const calendarType = this.calendartype;
+        const view = this.view;
+        let result;
+        if (view === 'month') {
+            result = (calendarType === VIEW_TYPES.LIST) ? 'listMonth' : 'dayGridMonth';
+        }
+        else if (view === 'week') {
+            result = (calendarType === VIEW_TYPES.BASIC) ? 'dayGridWeek' : (calendarType === VIEW_TYPES.LIST) ? 'listWeek' : 'timeGridWeek';
+        }
+        else if (view === 'day') {
+            result = (calendarType === VIEW_TYPES.BASIC) ? 'dayGridDay' : (calendarType === VIEW_TYPES.LIST) ? 'listDay' : 'timeGridDay';
+        }
+        else if (view === 'year') {
+            result = (calendarType === VIEW_TYPES.LIST) ? 'listYear' : '';
+        }
+        else {
+            result = viewKey;
+        }
+        return result;
+    }
+    /**
+     * @param operationType
+     * @param argumentKey
+     * @param argumentValue
+     * Handle various operations like Rendering Calendar, changing the calendar viewType, setting the calendarOptions according to the operationType.
+     */
+    applyCalendarOptions(operationType, argumentKey, argumentValue) {
+        switch (operationType) {
+            case 'render':
+                this.$fullCalendar.render();
+                break;
+            case 'option':
+                this.$fullCalendar.setOption(argumentKey, argumentValue);
+                break;
+            case 'changeView':
+                const view = this.getViewType(argumentKey);
+                this.$fullCalendar.changeView(view);
+                break;
+        }
+    }
+    /**
+     * Adds the new eventsDataSet to the calendar object with addEvent Method and re-renders the calendar
+     */
+    renderEventDataSet() {
+        const self = this;
+        this.$fullCalendar.batchRendering(function () {
+            const events = self.$fullCalendar.getEvents();
+            each(events, function (event) {
+                const eventData = self.$fullCalendar.getEventById(event.id);
+                eventData.remove();
+            });
+            each(self.dataSetEvents.events, function (event) {
+                self.$fullCalendar.addEvent(event);
+            });
+        });
+    }
+    ngOnDestroy() {
+        if (this.cancelLocaleChangeSubscription) {
+            this.cancelLocaleChangeSubscription();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalendarComponent, deps: [{ token: i0.Injector }, { token: i1.AbstractI18nService }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CalendarComponent, isStandalone: true, selector: "[wmCalendar]", providers: [
+            provideAsWidgetRef(CalendarComponent)
+        ], viewQueries: [{ propertyName: "_calendar", first: true, predicate: ["calendar"], descendants: true }, { propertyName: "_datepicker", first: true, predicate: ["datepicker"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<div #calendar></div>\n", encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CalendarComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: '[wmCalendar]', providers: [
+                        provideAsWidgetRef(CalendarComponent)
+                    ], encapsulation: ViewEncapsulation.None, template: "<div #calendar></div>\n" }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.AbstractI18nService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }], propDecorators: { _calendar: [{
+                type: ViewChild,
+                args: ['calendar']
+            }], _datepicker: [{
+                type: ViewChild,
+                args: ['datepicker']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/input/calendar/src/calendar.component.ts","../../../../../projects/components/widgets/input/calendar/src/calendar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    AfterViewInit,\n    Component,\n    ElementRef,\n    Inject,\n    Injector,\n    OnDestroy,\n    OnInit,\n    Optional,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\n\nimport {AbstractI18nService, getClonedObject, getSessionStorageItem, isMobile} from '@wm/core';\n\nimport {\n    APPLY_STYLES_TYPE,\n    createArrayFrom,\n    getEvaluatedData,\n    IRedrawableComponent,\n    provideAsWidgetRef,\n    StylableComponent,\n    styler\n} from '@wm/components/base';\n\nimport {registerProps} from './calendar.props';\nimport {capitalize, clone, each, extend, get, includes, isDate, isEmpty, isObject, mapKeys} from \"lodash-es\";\n\ndeclare const $;\nimport * as momentLib  from 'moment';\nconst moment = momentLib.default || window['moment'];\nimport {Calendar} from '@fullcalendar/core';\nimport dayGridPlugin from '@fullcalendar/daygrid';\nimport timeGridPlugin from '@fullcalendar/timegrid';\nimport listPlugin from '@fullcalendar/list'\nimport interactionPlugin from '@fullcalendar/interaction';\nimport allLocales from '@fullcalendar/core/locales-all';\n\nconst DEFAULT_CLS = 'app-calendar';\nconst dateFormats = ['yyyy-MM-dd', 'yyyy-M-dd', 'M-dd-yyyy', 'MM-dd-yy', 'yyyy, dd MMMM', 'yyyy, MMM dd', 'MM/dd/yyyy', 'M/d/yyyy', 'EEE, dd MMM yyyy', 'EEE MMM dd yyyy', 'EEEE, MMMM dd, yyyy', 'timestamp'];\nconst defaultHeaderOptions = {\n    start: 'prev next today',\n    center: 'title',\n    end: 'dayGridMonth dayGridWeek dayGridDay'\n};\nconst VIEW_TYPES = {\n    BASIC: 'basic',\n    AGENDA: 'agenda',\n    LIST: 'list'\n};\nconst BUTTON_TEXT = {\n    YEAR: 'Year',\n    MONTH: 'Month',\n    WEEK: 'Week',\n    DAY: 'Day',\n    TODAY: 'Today'\n};\nconst SELECTION_MODES = {\n    NONE: 'none',\n    SINGLE: 'single',\n    MULTIPLE: 'multiple'\n};\nconst NEXT_DAY_THRESHOLD = {\n    START: '00:00',\n    END: '24:00'\n};\nconst getEventMomentValue = (value, key) => {\n    let isDate = false;\n\n    dateFormats.forEach((format) => {\n        // moment supports uppercase formats\n        if (moment(value, format.toUpperCase(), true).isValid()) {\n            isDate = true;\n            return false;\n        }\n    });\n\n    // if the value is date then for end date the value should be end of the day as the calendar is approximating it to the start.\n    if (isDate && key === 'end') {\n        return moment(value).endOf('day');\n    }\n\n    return moment(value);\n};\nconst getUTCDateTime = (dateObj) => {\n    dateObj = moment(dateObj);\n    const year = dateObj.format('YYYY'),\n        // javascript starts the month count from '0' where as moment returns the human count\n        month = dateObj.format('MM') - 1,\n        day = dateObj.format('DD'),\n        hours = dateObj.format('HH'),\n        minutes = dateObj.format('mm'),\n        seconds = dateObj.format('ss');\n    return new Date(year, month, day, hours, minutes, seconds);\n};\nconst WIDGET_CONFIG = {widgetType: 'wm-calendar', hostClass: DEFAULT_CLS};\nconst dateFormat = 'YYYY/MM/DD';\n\n@Component({\n    standalone: true,\n    selector: '[wmCalendar]',\n    templateUrl: './calendar.component.html',\n    styleUrls: [],\n    providers: [\n        provideAsWidgetRef(CalendarComponent)\n    ],\n    encapsulation: ViewEncapsulation.None\n})\nexport class CalendarComponent extends StylableComponent implements AfterContentInit, AfterViewInit, OnInit, OnDestroy, IRedrawableComponent {\n    static initializeProps = registerProps();\n    // The calendar element reference\n    @ViewChild('calendar') _calendar: ElementRef;\n    @ViewChild('datepicker') _datepicker: ElementRef;\n\n    public selecteddates: any;\n    public selecteddata: any;\n    public currentview: object;\n    public dataset: any;\n    public calendartype;\n    public controls = 'navigation, today, year, month, week, day';\n    public datavalue;\n    public eventtitle;\n    public eventstart;\n    public eventend;\n    public eventallday;\n    public eventclass;\n\n    private eventSources: Array<any> = [];\n\n    private dataSetEvents = {\n        events: []\n    };\n    private oldData;\n    // map the fullcalendar Element rendered\n    private $fullCalendar;\n    // model to the mobile calendar\n    private proxyModel;\n    private eventData;\n    private events;\n    private changesStack = [];\n\n    // calendarOptions to the calendar\n    private calendarOptions: any = {\n        calendar: {\n            height: 600,\n            eventSources: this.eventSources,\n            editable: true,\n            locale: getSessionStorageItem('selectedLocale') || 'en',\n            selectable: false,\n            longPressDelay: isMobile() ? 1 : 1000,\n            headerToolbar: defaultHeaderOptions,\n            nextDayThreshold: NEXT_DAY_THRESHOLD,\n            views: {\n                month: {\n                    dayMaxEventsRow: true\n                }\n            },\n            unselectAuto: false,\n            eventDrop: this.eventDrop.bind(this),\n            eventResizeStart: this.onEventChangeStart.bind(this),\n            eventDragStart: this.onEventChangeStart.bind(this),\n            eventResize: this.eventResize.bind(this),\n            eventClick: this.eventClick.bind(this),\n            select: this.select.bind(this),\n            eventDidMount: this.eventDidMount.bind(this),\n            viewDidMount: this.viewDidMount.bind(this),\n            datesSet: this.datesSet.bind(this),\n            dateClick: this.dateClick.bind(this)\n        }\n    };\n    public view: string;\n    private dayClass: Array<any> = [];\n    private cancelLocaleChangeSubscription;\n\n    // this function selects the default date given for the calendar\n    selectDate() {\n        let start, end;\n        // checks if datavalue is an object and not a Date object\n        if (isObject(this.datavalue) && !isDate(this.datavalue)) {\n            // @ts-ignore\n            start = moment(this.datavalue.start);\n            // @ts-ignore\n            end   = moment(this.datavalue.end);\n        } else {\n            start = moment(this.datavalue);\n            end   = moment(this.datavalue).add(1, 'day').startOf('day');\n        }\n        this.$fullCalendar.gotoDate( (moment(start) as any)._d); // after selecting the date go to the date.\n\n        this.$fullCalendar.select(start.valueOf(), end.valueOf());\n    }\n\n    // changes the calendar view to the default date given for the calendar.\n    public gotoDate() {\n        this.$fullCalendar.gotoDate( (moment(this.datavalue) as any)._d);\n    }\n\n    // this function takes the calendar view to the a year ahead\n    public gotoNextYear() {\n        this.$fullCalendar.nextYear();\n    }\n\n    // this function takes the calendar view to the a year before\n    public gotoPrevYear() {\n        this.$fullCalendar.prevYear();\n    }\n\n    /**\n     * this function takes the calendar view to the specified month\n     * @param monthVal, 1-12 value of month\n     */\n    public gotoMonth(monthVal) {\n        let presentDay = this.$fullCalendar.getDate();\n        const presentMonthVal = presentDay.getMonth();\n        presentDay = moment(presentDay);\n        if (presentMonthVal < monthVal) {\n            this.$fullCalendar.gotoDate(presentDay.add(monthVal - presentMonthVal - 1, 'M').valueOf());\n        } else {\n            this.$fullCalendar.gotoDate(presentDay.subtract( presentMonthVal - monthVal + 1, 'M').valueOf());\n        }\n    }\n\n    // this function takes the calendar view to the a month ahead\n    public gotoNextMonth() {\n        const presentDay = moment(this.$fullCalendar.getDate());\n        this.$fullCalendar.gotoDate(presentDay.add(1, 'M').valueOf());\n    }\n\n    // this function takes the calendar view to the a month before\n    public gotoPrevMonth() {\n        const presentDay = moment(this.$fullCalendar.getDate());\n        this.$fullCalendar.gotoDate(presentDay.subtract(1, 'M').valueOf());\n    }\n\n\n    // this function re-renders the events assigned to the calendar.\n    public rerenderEvents() {\n        this.$fullCalendar.render();\n    }\n\n    private setSelectedData(start, end) {\n        let dataset = this.dataset;\n        if (!dataset) {\n            return;\n        }\n\n        const filteredDates = [];\n        const eventStartKey = this.eventstart || 'start';\n        const eventEndKey = this.eventend || 'end';\n        const startDate = moment(new Date(start)).format('MM/DD/YYYY');\n        const endDate = moment(new Date(end)).subtract(1, 'days').format('MM/DD/YYYY');\n\n        dataset = dataset.data || dataset;\n        dataset.forEach((value) => {\n            if (!value[eventStartKey]) {\n                return;\n            }\n            const eventStartDate   = moment(new Date(value[eventStartKey])).format('MM/DD/YYYY');\n            const eventEndDate   = moment(new Date(value[eventEndKey] || value[eventStartKey])).format('MM/DD/YYYY');\n            const eventExists = moment(eventStartDate).isSameOrAfter(startDate) && moment(eventEndDate).isSameOrBefore(endDate);\n            if (eventExists) {\n                filteredDates.push(value);\n            }\n        });\n        return filteredDates;\n    }\n\n    private eventDrop(eventDropInfo) {\n        let newDataObj = this.convertEventObjForOldAndNewData(eventDropInfo.event);\n        let oldDataObj = this.convertEventObjForOldAndNewData(eventDropInfo.oldEvent);\n        this.invokeEventCallback('eventdrop', {$event: eventDropInfo.jsEvent, $newData: newDataObj, $oldData: oldDataObj, $delta: eventDropInfo.delta, $revertFunc: eventDropInfo.revert, $ui: {}, $view: eventDropInfo.view});\n    }\n\n    // Returns the default date when the datavalue is provided\n    getDefaultDate() {\n        if (this.datavalue) {\n            return new Date(this.datavalue);\n        }\n    }\n\n    getDefaultOptions() {\n        return this.calendarOptions;\n    }\n\n    getLib() {\n        return 'fullcalendar';\n    }\n\n    private select($selectionInfo) {\n        this.selecteddates = {start: getUTCDateTime($selectionInfo.start), end: getUTCDateTime($selectionInfo.end)};\n        this.selecteddata = this.setSelectedData($selectionInfo.start, $selectionInfo.end);\n        this.invokeEventCallback('select', {$start: $selectionInfo.start.valueOf(), $end: $selectionInfo.end.valueOf(), $view: $selectionInfo.view, $data: this.selecteddata});\n    }\n\n    /**\n     *  this functions unselects all the selections in calendar\n     */\n    public unselect() {\n        this.$fullCalendar.unselect();\n    }\n\n    /**\n     * this function is to add extendedProps data to the data object.\n     * this is done for backward compatibility\n     * @param eventObj event object as per new version (v5)\n     * @returns _eventMetadata event object as per the old version (v3)\n     */\n    private convertEventObj(eventObj) {\n        if (!eventObj.extendedProps._eventMetadata) {\n            return eventObj;\n        }\n        const _eventMetadata = eventObj.extendedProps._eventMetadata;\n        Object.setPrototypeOf(_eventMetadata, eventObj);\n        return _eventMetadata;\n    }\n\n    /**\n     *  this function is to add extendedProps data to the data object exluding start end title allDay objects if the key name matches.\n     * * this is done for backward compatibility\n     * @param eventObj event object as per new version (v5)\n     * @returns data event object as per the old version (v3)\n     */\n    private convertEventObjForOldAndNewData(eventObj) {\n        const _eventMetadata = eventObj.extendedProps;\n        extend(eventObj, _eventMetadata);\n        return eventObj;\n    }\n\n    private eventResize(eventResizeInfo) {\n        let newDataObj = this.convertEventObjForOldAndNewData(eventResizeInfo.event);\n        let oldDataObj = this.convertEventObjForOldAndNewData(eventResizeInfo.oldEvent);\n        this.invokeEventCallback('eventresize', {$event: eventResizeInfo.jsEvent, $newData: newDataObj, $oldData: oldDataObj, $delta: eventResizeInfo.delta, $revertFunc: eventResizeInfo.revert, $ui: {}, $view: eventResizeInfo.view});\n    }\n\n    private onEventChangeStart(event) {\n        this.oldData = getClonedObject(event);\n    }\n\n    private eventClick(eventClickInfo) {\n        let eventObj = this.convertEventObj(eventClickInfo.event);\n        this.invokeEventCallback('eventclick', {$event: eventClickInfo.jsEvent, $data: eventObj, $view: eventClickInfo.view});\n    }\n\n    private eventDidMount(event) {\n        let eventObj = this.convertEventObj(event.event);\n        if (this.calendartype === VIEW_TYPES.LIST) {\n            this.$element.find('.fc-list-table').addClass('table');\n        }\n        this.invokeEventCallback('eventrender', {$event: event.el, $data: eventObj, $view: event.view});\n    }\n\n    private viewDidMount($view) {\n        if (this.calendartype === VIEW_TYPES.LIST) {\n            this.$element.find('.fc-list-table').addClass('table');\n        }\n        this.invokeEventCallback('viewrender', {$view: $view});\n    }\n\n    /**\n     * This function gets called when the view of the calendar changes.\n     * @param data contains the start end data of the calendar view.\n     */\n    private datesSet(data) {\n        this.currentview = {start: moment(data.start).format(\"YYYY-MM-DD\"), end: moment(data.end).format(\"YYYY-MM-DD\")};\n    }\n\n    private dateClick($info) {\n        const dateInfo = getUTCDateTime($info.date).valueOf();\n        this.invokeEventCallback('dateclick', {$dateInfo: dateInfo});\n    }\n\n    // update the calendar header options once the controls changes\n    private updateCalendarHeaderOptions() {\n        const ctrls = this.controls, viewType = this.calendartype,\n            regEx = new RegExp('\\\\bday\\\\b', 'g');\n        let left = '', right = '';\n        if (ctrls && viewType) {\n            if (includes(ctrls, 'navigation')) {\n                left += ' prev next';\n            }\n\n            if (includes(ctrls, 'today')) {\n                left += ' today';\n            }\n\n            if (includes(ctrls, 'year')) {\n                right += (viewType === VIEW_TYPES.LIST) ? 'listYear' : '';\n            }\n\n            if (includes(ctrls, 'month')) {\n                right += (viewType === VIEW_TYPES.LIST) ? ' listMonth' : ' dayGridMonth';\n            }\n\n            if (includes(ctrls, 'week')) {\n                right += (viewType === VIEW_TYPES.BASIC) ?  ' dayGridWeek' : (viewType === VIEW_TYPES.LIST) ? ' listWeek' : ' timeGridWeek';\n            }\n\n            if (regEx.test(ctrls)) {\n                right += (viewType === VIEW_TYPES.BASIC) ?  ' dayGridDay' : (viewType === VIEW_TYPES.LIST) ? ' listDay' : ' timeGridDay';\n            }\n            if (left.charAt(0) === ' ') {\n                left = left.substring(1);\n            }\n            if (right.charAt(0) === ' ') {\n                right = right.substring(1);\n            }\n            extend(this.calendarOptions.calendar.headerToolbar, {'start': left, 'end': right});\n        }\n    }\n\n    constructor(inj: Injector, i18nService: AbstractI18nService, @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any) {\n        super(inj, WIDGET_CONFIG, explicitContext);\n\n        this.eventSources.push(this.dataSetEvents);\n        let FullCalendar = window['FullCalendar'] ? window['FullCalendar'] : Calendar;\n        if (!FullCalendar.__wm_locale_initialized) {\n            i18nService.initCalendarLocale();\n            FullCalendar.__wm_locale_initialized = true;\n        }\n\n        this.cancelLocaleChangeSubscription = this.getAppInstance().subscribe(\"locale-changed\", (libLocale) => {\n            this.setLocale();\n            this.applyCalendarOptions('option', 'locale', libLocale.fullCalendar || 'en');\n            this.redraw();\n        });\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n        styler(this.nativeElement, this, APPLY_STYLES_TYPE.CONTAINER, ['height']);\n        this.setLocale();\n    }\n\n    onStyleChange(key, nv, ov?) {\n        super.onStyleChange(key, nv, ov);\n        if (key === 'height') {\n            this.calendarOptions.calendar.height = this.calculateHeight(nv);\n            this.updateCalendarOptions('option', 'height', this.calendarOptions.calendar.height);\n        }\n    }\n\n    onPropertyChange(key, nv, ov?) {\n        super.onPropertyChange(key, nv, ov);\n        switch (key) {\n            case 'selectionmode':\n                if (nv !== SELECTION_MODES.NONE) {\n                    this.calendarOptions.calendar.selectable = true;\n                    this.updateCalendarOptions('option', 'selectable', true);\n                    if (nv === SELECTION_MODES.SINGLE) {\n                        this.calendarOptions.calendar.selectConstraint = {\n                            startTime: '00:00',\n                            endTime: '24:00'\n                        };\n                        this.updateCalendarOptions('option', 'selectConstraint', this.calendarOptions.calendar.selectConstraint);\n                    } else {\n                        this.updateCalendarOptions('option', 'selectConstraint', {});\n                    }\n                } else {\n                    this.calendarOptions.calendar.selectable = false;\n                    this.updateCalendarOptions('option', 'selectable', false);\n                }\n                break;\n            case 'view':\n                if (nv !== 'month' || this.calendartype === VIEW_TYPES.LIST) {\n                    this.calendarOptions.calendar.defaultView = this.calendartype + capitalize(nv);\n                } else {\n                    this.calendarOptions.calendar.defaultView = nv;\n                }\n                this.updateCalendarOptions('changeView', this.calendarOptions.calendar.defaultView);\n                break;\n            case 'calendartype':\n                this.calendartype = nv || 'dayGrid';\n            case 'controls':\n                this.updateCalendarHeaderOptions();\n                break;\n            case 'dataset':\n                let dataSet;\n                const self = this;\n                this.dataset = nv;\n                dataSet = createArrayFrom(getClonedObject(nv));\n                dataSet = this.constructCalendarDataset(dataSet);\n                this.dataSetEvents.events = dataSet.filter((event) => {\n                    event.start = event.start || event.end;\n                    if (event.start) {\n                        return true;\n                    }\n                });\n\n                this.renderEventDataSet();\n                break;\n            case 'show':\n                this.$fullCalendar?.changeView(this.getViewType(this.view ? this.view : 'dayGridMonth'));\n        }\n    }\n\n    // to calculate the height for the event limit and parsing the value when it is percentage based.\n    private calculateHeight(height): number {\n        const $parent = $(this.nativeElement).parent(),\n            elHeight = height || '650px';\n\n        let parentHeight: any = $parent.css('height'),\n            computedHeight: number;\n\n        if (includes(elHeight, '%')) {\n            if (includes(parentHeight, '%')) {\n                parentHeight = $parent.height();\n            }\n            computedHeight = (parseInt(parentHeight, 10) * Number(elHeight.replace(/\\%/g, ''))) / 100;\n        } else {\n            computedHeight = parseInt(elHeight, 10);\n        }\n        this.calendarOptions.calendar.views.month.eventLimit = parseInt('' + computedHeight / 200, 10) + 1;\n        return computedHeight;\n    }\n\n    ngAfterViewInit() {\n        super.ngAfterViewInit();\n        const calendarEl = this._calendar.nativeElement;\n        let FullCalendar:any ;\n        if(window['FullCalendar']) FullCalendar = window['FullCalendar'].Calendar \n        else {\n            FullCalendar = Calendar;\n            this.calendarOptions.calendar = {...this.calendarOptions.calendar, plugins: [dayGridPlugin, timeGridPlugin, listPlugin,listPlugin, interactionPlugin], locales: allLocales}\n        }\n\n        const calendar = new FullCalendar(calendarEl, this.calendarOptions.calendar);\n        this.$fullCalendar =  calendar;\n        this.invokeEventCallback('beforerender', {'$event' : {}});\n        calendar.render();\n\n        // if the changes are already stacked before calendar renders then execute them when needed\n        if (this.changesStack.length) {\n            this.changesStack.forEach((changeObj) => {\n                this.applyCalendarOptions(changeObj.operationType, changeObj.argumentKey, changeObj.argumentValue);\n            });\n            this.changesStack.length = 0;\n        }\n        $(\".fc-prev-button\").attr(\"aria-label\", \"prev\");\n        $(\".fc-next-button\").attr(\"aria-label\", \"next\");\n        $(\".fc-today-button\").attr(\"aria-label\", \"today\");\n\n        //WMS-22412 : change calender's view based on the configuration set from studio\n        setTimeout(() => {\n            this.$fullCalendar.changeView(this.getViewType(this.view ? this.view : 'dayGridMonth'));\n        },50);\n    }\n\n    // constructs the calendar dataset by mapping the eventstart, eventend, eventtitle etc.,\n    private constructCalendarDataset(eventSource) {\n        const properties = {\n            title: this.eventtitle || 'title',\n            allDay: this.eventallday || 'allday',\n            start: this.eventstart || 'start',\n            end: this.eventend || 'end',\n            className: this.eventclass || 'className'\n        };\n\n        eventSource.forEach((obj) => {\n            obj._eventMetadata = clone(obj);\n            if (isEmpty(obj._eventMetadata.url)) {\n                delete obj._eventMetadata.url;\n            }\n            if (isEmpty(obj.url)) {\n                delete obj.url;\n            }\n\n            mapKeys(properties, (value, key) => {\n                let objVal;\n                if (key === 'title') {\n                    objVal = getEvaluatedData(obj, {expression: value}, this.viewParent);\n                } else if (key === 'allDay') {\n                    objVal = !!get(obj, value);\n                } else {\n                    objVal = get(obj, value);\n                }\n                if (!objVal) {\n                    return;\n                }\n                obj[key] = objVal;\n            });\n        });\n        return eventSource;\n    }\n\n    private setLocale() {\n        const year = get(this.appLocale, 'LABEL_CALENDAR_YEAR') || BUTTON_TEXT.YEAR;\n        const month = get(this.appLocale, 'LABEL_CALENDAR_MONTH') || BUTTON_TEXT.MONTH;\n        const week = get(this.appLocale, 'LABEL_CALENDAR_WEEK') || BUTTON_TEXT.WEEK;\n        const day = get(this.appLocale, 'LABEL_CALENDAR_DAY') || BUTTON_TEXT.DAY;\n        const today = get(this.appLocale, 'LABEL_CALENDAR_TODAY') || BUTTON_TEXT.TODAY;\n        this.calendarOptions.calendar.buttonText    = { year, month, week, day, today,\n            'listYear': year,\n            'listMonth': month,\n            'listWeek': week,\n            'listDay': day\n        };\n    }\n\n    /**\n     * override the default calendar options with the newSet of options\n     * @param options\n     */\n    overrideDefaults(options) {\n        if (isObject(options)) {\n            Object.entries(options).map(option => this.$fullCalendar.setOption(option[0], option[1]));\n        }\n    }\n\n    /**\n     * if the operations are performed before the calendar renders, the changes are pushed into changesStack and will be executed after the calendar gets rendered\n     * if the calendar is already rendered, then the specific operation will be performed according to the operation type\n     * @param operationType\n     * @param argumentKey\n     * @param argumentValue\n     */\n    updateCalendarOptions(operationType: string, argumentKey?: any, argumentValue?: any): void {//\n        if (!this.$fullCalendar) {\n            this.changesStack.push({\n                operationType: operationType,\n                argumentKey: argumentKey,\n                argumentValue: argumentValue\n            });\n            return;\n        }\n        this.applyCalendarOptions(operationType, argumentKey, argumentValue);\n    }\n\n    redraw() {\n        this.updateCalendarOptions('render');\n        this.$fullCalendar?.changeView(this.getViewType(this.view ? this.view : 'dayGridMonth'));\n    }\n\n    // on date change invoke the select event, and if date has event on it then invoke the event click.\n    private onValueChange(value: Date): void {\n        this.proxyModel = value;\n        const selectedDate        = this.proxyModel && moment(this.proxyModel).startOf('day').format(dateFormat),\n            selectedEventData   = this.eventData[selectedDate],\n            start               = moment(this.proxyModel),\n            end                 = moment(this.proxyModel).endOf('day');\n        this.selecteddata = selectedEventData;\n        this.selecteddates = {\n            'start': moment(selectedDate).valueOf(),\n            'end'  : moment(selectedDate).endOf('day').valueOf()\n        };\n        this.calendarOptions.calendar.select(start.valueOf(), end.valueOf(), {}, this, selectedEventData);\n        if (selectedEventData) {\n            this.calendarOptions.calendar.eventClick(selectedEventData, {}, this);\n        }\n    }\n\n    /**\n     * This function will receive an object containing source of calendar, apikey and calendarId and will integrate the respective calendar with fullcalendar.\n     * @param eventObject\n     */\n    public addEventSource(eventObject) {\n        if (isEmpty(eventObject)) {\n            console.warn('addEventSource method requires an object as a parameter.');\n            return;\n        }\n        if (eventObject.source === 'google') {\n            if (!eventObject.googleCalendarApiKey || !eventObject.googleCalendarId ) {\n                console.warn('For google calendar integration, \\'googleCalendarApiKey\\' and \\'googleCalendarId\\' should be passed in the parameter object.');\n                return;\n            }\n            this.$fullCalendar.setOption('googleCalendarApiKey', eventObject.googleCalendarApiKey);\n            this.$fullCalendar.addEventSource({\n                googleCalendarId: eventObject.googleCalendarId\n            });\n        }\n    }\n\n    /**\n     * get the viewTypeKey according to the calendarType and viewType selected\n     * @param viewKey\n     */\n    getViewType(viewKey) {\n        const calendarType = this.calendartype;\n        const view = this.view;\n        let result;\n\n        if (view === 'month') {\n            result = (calendarType === VIEW_TYPES.LIST) ? 'listMonth' : 'dayGridMonth';\n        } else if (view === 'week') {\n            result = (calendarType === VIEW_TYPES.BASIC) ?  'dayGridWeek' : (calendarType === VIEW_TYPES.LIST) ? 'listWeek' : 'timeGridWeek';\n        } else if (view === 'day') {\n            result = (calendarType === VIEW_TYPES.BASIC) ?  'dayGridDay' : (calendarType === VIEW_TYPES.LIST) ? 'listDay' : 'timeGridDay';\n        } else if (view === 'year') {\n            result = (calendarType === VIEW_TYPES.LIST) ? 'listYear' : '';\n        } else {\n            result = viewKey;\n        }\n        return result;\n    }\n\n    /**\n     * @param operationType\n     * @param argumentKey\n     * @param argumentValue\n     * Handle various operations like Rendering Calendar, changing the calendar viewType, setting the calendarOptions according to the operationType.\n     */\n    applyCalendarOptions(operationType: string, argumentKey?: any, argumentValue?: any): void {\n        switch (operationType) {\n            case 'render':\n                this.$fullCalendar.render();\n                break;\n            case 'option':\n                this.$fullCalendar.setOption(argumentKey, argumentValue);\n                break;\n            case 'changeView':\n                const view = this.getViewType(argumentKey);\n                this.$fullCalendar.changeView(view);\n                break;\n        }\n    }\n\n    /**\n     * Adds the new eventsDataSet to the calendar object with addEvent Method and re-renders the calendar\n     */\n    renderEventDataSet() {\n        const self = this;\n        this.$fullCalendar.batchRendering(function() {\n            const events = self.$fullCalendar.getEvents();\n            each(events, function (event) {\n                const eventData = self.$fullCalendar.getEventById(event.id);\n                eventData.remove();\n            });\n            each(self.dataSetEvents.events, function (event) {\n                self.$fullCalendar.addEvent(event);\n            });\n        });\n    }\n\n    ngOnDestroy() {\n        if(this.cancelLocaleChangeSubscription) {\n            this.cancelLocaleChangeSubscription();\n        }\n    }\n}\n","<div #calendar></div>\n"]}