@syncfusion/ej2-schedule 30.2.7 → 31.1.17

package/dist/ts/schedule/exports/calendar-export.d.ts

@@ -0,0 +1,16 @@
+import { Schedule } from '../base/schedule';
+/**
+ * ICalendar Export Module
+ */
+export declare class ICalendarExport {
+    private parent;
+    constructor(parent: Schedule);
+    initializeCalendarExport(fileName: string, customData: Record<string, any>[]): void;
+    getCalendarString(fileName?: string, customData?: Record<string, any>[]): string;
+    private customFieldFilter;
+    private convertDateToString;
+    private download;
+    private filterEvents;
+    protected getModuleName(): string;
+    destroy(): void;
+}

package/dist/ts/schedule/exports/calendar-export.ts

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { extend } from '@syncfusion/ej2-base';
+import { EventFieldsMapping } from '../base/interface';
+import { getDateFromRecurrenceDateString, getRecurrenceStringFromDate } from '../../recurrence-editor/date-generator';
+import { Schedule } from '../base/schedule';
+
+/**
+ * ICalendar Export Module
+ */
+
+export class ICalendarExport {
+    private parent: Schedule;
+    constructor(parent: Schedule) {
+        this.parent = parent;
+    }
+
+    public initializeCalendarExport(fileName: string, customData: Record<string, any>[]): void {
+        const icsString: string = this.getCalendarString(fileName, customData);
+        this.download(icsString, fileName);
+    }
+
+    public getCalendarString(fileName?: string, customData?: Record<string, any>[]): string {
+        let eventsData: Record<string, any>[] = (customData) ? customData :
+            extend([], this.parent.eventsData, null, true) as Record<string, any>[];
+        eventsData = this.parent.eventBase.sortByTime(eventsData);
+        const SEPARATOR: string = (navigator.appVersion.indexOf('Win') !== -1) ? '\r\n' : '\n';
+        const iCalendarEvents: string[] = [];
+        const filterCollection: Record<string, any>[] = [];
+        const timeZone: string = this.parent.timezone || this.parent.tzModule.getLocalTimezoneName();
+        const fields: EventFieldsMapping = this.parent.eventFields;
+        eventsData.forEach((eventObj: Record<string, any>) => {
+            let uId: string = eventObj[fields.id] || eventObj.Guid || this.parent.eventBase.generateGuid();
+            const editedExDate: string[] = [];
+            if (eventObj[fields.recurrenceID]) {
+                const filter: Record<string, any>[] =
+                    this.filterEvents(filterCollection, fields.id, eventObj[fields.recurrenceID] as number);
+                uId = filter.length > 0 ? filter[0].UID as string : uId;
+            }
+            if (!eventObj[fields.recurrenceID] && eventObj[fields.recurrenceRule] && eventObj[fields.recurrenceException]) {
+                const exDate: string[] = ((eventObj[fields.recurrenceException]) as string).split(',');
+                const editedObj: Record<string, any>[] =
+                    this.filterEvents(eventsData, fields.recurrenceID, eventObj[fields.id] as number);
+                editedObj.forEach((edited: Record<string, any>) => {
+                    editedExDate.push(getRecurrenceStringFromDate(edited[fields.startTime] as Date));
+                });
+                const exceptionDateList: string[] = exDate.filter((value: string) => editedExDate.indexOf(value) === -1);
+                eventObj[fields.recurrenceException] = (exceptionDateList.length > 0) ? (exceptionDateList.join(',') + ',') : '';
+            }
+            const startZone: string = (eventObj[fields.startTimezone] || timeZone) as string;
+            const endZone: string = (eventObj[fields.endTimezone] || timeZone) as string;
+            const readonly: boolean = (eventObj[fields.isReadonly]) ? (eventObj[fields.isReadonly]) : false;
+            const calendarEvent: string[] = [
+                'BEGIN:VEVENT',
+                'LOCATION:' + (eventObj[fields.location] || ''),
+                'SUMMARY:' + (eventObj[fields.subject] || ''),
+                'UID:' + uId,
+                'DESCRIPTION:' + (eventObj[fields.description] || ''),
+                'ISREADONLY:' + readonly,
+                'END:VEVENT'
+            ];
+            if (eventObj[fields.isAllDay]) {
+                calendarEvent.splice(4, 0, 'DTEND;VALUE=DATE:' + this.convertDateToString(eventObj[fields.endTime] as Date, true));
+                calendarEvent.splice(4, 0, 'DTSTART;VALUE=DATE:' + this.convertDateToString(eventObj[fields.startTime] as Date, true));
+            } else if (!eventObj[fields.isAllDay] && !eventObj[fields.recurrenceRule]) {
+                calendarEvent.splice(4, 0, 'DTEND:' + this.convertDateToString(eventObj[fields.endTime] as Date));
+                calendarEvent.splice(4, 0, 'DTSTART:' + this.convertDateToString(eventObj[fields.startTime] as Date));
+            } else {
+                calendarEvent.splice(4, 0, 'DTEND;TZID="' + endZone + '":' + this.convertDateToString(eventObj[fields.endTime] as Date));
+                calendarEvent.splice(4, 0, 'DTSTART;TZID="' + startZone + '":'
+                    + this.convertDateToString(eventObj[fields.startTime] as Date));
+            }
+            if (eventObj[fields.recurrenceRule]) {
+                calendarEvent.splice(4, 0, 'RRULE:' + eventObj[fields.recurrenceRule]);
+            }
+            if (eventObj[fields.recurrenceException]) {
+                const exDate: string[] = (eventObj[fields.recurrenceException] as string).split(',');
+                for (let i: number = 0; i < exDate.length - 1; i++) {
+                    calendarEvent.splice(5, 0, 'EXDATE:' +
+                        this.convertDateToString(
+                            getDateFromRecurrenceDateString(exDate[parseInt(i.toString(), 10)]), eventObj[fields.isAllDay] as boolean));
+                }
+            }
+            if (eventObj[fields.recurrenceID]) {
+                calendarEvent.splice(4, 0, 'RECURRENCE-ID;TZID="' + startZone + '":'
+                    + this.convertDateToString(eventObj[fields.startTime] as Date, eventObj[fields.isAllDay] as boolean));
+            }
+            const customFields: string[] = this.customFieldFilter(eventObj, fields);
+            if (customFields.length > 0) {
+                customFields.forEach((customField: string) =>
+                    calendarEvent.splice(4, 0, customField + ':' + (eventObj[`${customField}`] || ''))
+                );
+            }
+            const app: Record<string, any> = <Record<string, any>>extend({}, eventObj);
+            app.UID = uId;
+            filterCollection.push(app);
+            iCalendarEvents.push(calendarEvent.join(SEPARATOR));
+
+        });
+        const iCalendar: string = [
+            'BEGIN:VCALENDAR',
+            'PRODID:-//Syncfusion Inc//Scheduler//EN',
+            'VERSION:2.0',
+            'CALSCALE:GREGORIAN',
+            'METHOD:PUBLISH',
+            'X-WR-CALNAME:' + (fileName || 'Calendar'),
+            'X-WR-TIMEZONE:' + timeZone
+        ].join(SEPARATOR);
+        const icsString: string = iCalendar + SEPARATOR + iCalendarEvents.join(SEPARATOR) + SEPARATOR + 'END:VCALENDAR';
+        return icsString;
+    }
+    private customFieldFilter(eventObj: Record<string, any>, fields: EventFieldsMapping): string[] {
+        const defaultFields: string[] = Object.keys(fields).map((key: string) => (fields as Record<string, any>)[`${key}`]) as string[];
+        const eventFields: string[] = Object.keys(eventObj);
+        return eventFields.filter((value: string) => (defaultFields.indexOf(value) === -1) && (value !== 'Guid'));
+    }
+
+    private convertDateToString(eventDate: Date, allDay?: boolean): string {
+        const year: string = ('0000' + (eventDate.getFullYear().toString())).slice(-4);
+        const month: string = ('00' + ((eventDate.getMonth() + 1).toString())).slice(-2);
+        const date: string = ('00' + ((eventDate.getDate()).toString())).slice(-2);
+        const hours: string = ('00' + (eventDate.getHours().toString())).slice(-2);
+        const minutes: string = ('00' + (eventDate.getMinutes().toString())).slice(-2);
+        const seconds: string = ('00' + (eventDate.getSeconds().toString())).slice(-2);
+        const timeString: string = (allDay) ? year + month + date : year + month + date + 'T' + hours + minutes + seconds;
+        return timeString;
+    }
+
+    private download(icsString: string, fileName: string): void {
+        const buffer: Blob = new Blob([icsString], { type: 'data:text/calendar;charset=utf8' });
+        fileName = (fileName || 'Calendar') + '.ics';
+        if (navigator.msSaveBlob) {
+            navigator.msSaveBlob(buffer, fileName);
+        } else {
+            const downloadLink: HTMLAnchorElement = document.createElementNS('http://www.w3.org/1999/xhtml', 'a') as HTMLAnchorElement;
+            downloadLink.download = fileName;
+            downloadLink.href = URL.createObjectURL(buffer);
+            const event: MouseEvent = document.createEvent('MouseEvent');
+            event.initEvent('click', true, true);
+            downloadLink.dispatchEvent(event);
+            setTimeout((): void => {
+                URL.revokeObjectURL(downloadLink.href);
+                downloadLink.href = undefined;
+            });
+        }
+    }
+
+    private filterEvents(data: Record<string, any>[], field: string, value: number): Record<string, any>[] {
+        return data.filter((e: Record<string, any>) => e[`${field}`] === value);
+    }
+
+    protected getModuleName(): string {
+        return 'iCalendarExport';
+    }
+
+    public destroy(): void {
+        if (!this.parent || this.parent && this.parent.isDestroyed) { return; }
+        this.parent = null;
+    }
+
+}

package/dist/ts/schedule/exports/calendar-import.d.ts

@@ -0,0 +1,18 @@
+import { Schedule } from '../base/schedule';
+/**
+ * ICalendar Import Module
+ */
+export declare class ICalendarImport {
+    private parent;
+    private allDay;
+    constructor(parent: Schedule);
+    initializeCalendarImport(fileContent: Blob | string): void;
+    private iCalendarParser;
+    private updateEventData;
+    private processOccurrence;
+    private getExcludeDateString;
+    private getFormattedString;
+    private dateParsing;
+    protected getModuleName(): string;
+    destroy(): void;
+}

package/dist/ts/schedule/exports/calendar-import.ts

@@ -0,0 +1,277 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { isNullOrUndefined, extend } from '@syncfusion/ej2-base';
+import { Schedule } from '../base/schedule';
+import { EventFieldsMapping } from '../base/interface';
+import { getRecurrenceStringFromDate } from '../../recurrence-editor/date-generator';
+
+/**
+ * ICalendar Import Module
+ */
+
+export class ICalendarImport {
+    private parent: Schedule;
+    private allDay: boolean = false;
+    constructor(parent: Schedule) {
+        this.parent = parent;
+    }
+
+    public initializeCalendarImport(fileContent: Blob | string): void {
+        if (fileContent && fileContent instanceof Blob) {
+            const fileReader: FileReader = new FileReader();
+            fileReader.onload = () => {
+                const iCalString: string = fileReader.result as string;
+                this.iCalendarParser(iCalString);
+            };
+            fileReader.readAsText(fileContent as Blob, 'UTF-8');
+        } else if (fileContent && typeof fileContent === 'string') {
+            this.iCalendarParser(fileContent);
+        }
+    }
+
+    private iCalendarParser(iCalString: string): void {
+        let iCalData: Record<string, any> = {
+            isEvent: false,
+            curEvent: null,
+            id: this.parent.eventBase.getEventMaxID(),
+            count: 0,
+            events: [],
+            key: null
+        };
+        const iStringLength: number = iCalString.length;
+        let lastPosition: number = iCalString.search(/[^ \t]/);
+        let position: number = lastPosition;
+        let iString: string;
+        let newlineOffset: number;
+        do {
+            position = iCalString.indexOf('\n', lastPosition) + 1;
+            if (position === 0) {
+                position = iStringLength;
+                newlineOffset = 0;
+            } else if (position > 1 && iCalString[position - 2] === '\r') {
+                newlineOffset = 2;
+            } else {
+                newlineOffset = 1;
+            }
+            const firstChar: string = iCalString.charAt(lastPosition);
+            if (firstChar === ' ' || firstChar === '\n' || firstChar === '\t') {
+                iString += iCalString.slice(lastPosition + 1, position - newlineOffset);
+            } else {
+                if (iString) {
+                    iCalData = this.updateEventData(iString, iCalData);
+                }
+                iString = iCalString.slice(lastPosition, position - newlineOffset);
+            }
+            lastPosition = position;
+        } while (position !== iStringLength);
+        iString = iString.trim();
+        if (iString.length) {
+            iCalData = this.updateEventData(iString, iCalData);
+        }
+        const app: Record<string, any>[] = <Record<string, any>[]>extend([], iCalData.events, null, true);
+        this.parent.addEvent(this.processOccurrence(app, iCalData.id));
+    }
+
+    private updateEventData(iString: string, iCalData: Record<string, any>): Record<string, any> {
+        const fields: EventFieldsMapping = this.parent.eventFields;
+        const SEPARATOR: string = '\r\n';
+        const id: number | string = iCalData.id;
+        const events: Array<Record<string, any>> = iCalData.events;
+        let isEvent: boolean = iCalData.isEvent;
+        let count: number = iCalData.count;
+        let curEvent: Record<string, any> = iCalData.curEvent;
+        let key: string = iCalData.key;
+        if (!isEvent && iString === 'BEGIN:VEVENT') {
+            isEvent = true;
+            curEvent = {};
+        }
+        if (isEvent && iString === 'END:VEVENT') {
+            isEvent = false;
+            events.push(curEvent);
+            curEvent = null;
+        }
+        if (isEvent) {
+            const index: number = iString.indexOf(':');
+            let type: string = iString.substring(0, index).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+            let value: string = iString.substring(index + 1, iString.length).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+            if (iString.indexOf('SUMMARY') !== -1) {
+                type = 'SUMMARY';
+            }
+            if (iString.indexOf('DTSTART') !== -1) {
+                curEvent[fields.startTime] = this.dateParsing(iString);
+                curEvent[fields.isAllDay] = this.allDay;
+                this.allDay = false;
+            } else if (iString.indexOf('DTEND') !== -1) {
+                curEvent[fields.endTime] = this.dateParsing(iString);
+            } else if (iString.indexOf('EXDATE') !== -1) {
+                value = getRecurrenceStringFromDate(this.dateParsing(iString));
+                curEvent[fields.recurrenceException] = isNullOrUndefined(curEvent[fields.recurrenceException]) ?
+                    value : curEvent[fields.recurrenceException] + ',' + value;
+            } else if (iString.indexOf('RECURRENCE-ID') !== -1) {
+                value = getRecurrenceStringFromDate(this.dateParsing(iString));
+                curEvent[fields.recurrenceException] = value;
+                curEvent[fields.recurrenceID] = value;
+            } else {
+                key = type || key;
+                switch (key) {
+                case 'BEGIN':
+                    break;
+                case 'UID':
+                    curEvent[`${type}`] = value;
+                    if (typeof (id) == 'number') {
+                        curEvent[fields.id] = parseInt(value, 10);
+                        if (isNaN(curEvent[fields.id])) {
+                            curEvent[fields.id] = id + count;
+                            count++;
+                        }
+                    } else {
+                        curEvent[fields.id] = value;
+                    }
+                    break;
+                case 'SUMMARY':
+                    curEvent[fields.subject] = this.getFormattedString(value);
+                    break;
+                case 'LOCATION':
+                    curEvent[fields.location] = this.getFormattedString(value);
+                    break;
+                case 'DESCRIPTION':
+                    if (curEvent[fields.description]) {
+                        curEvent[fields.description] = this.getFormattedString(curEvent[fields.description] + SEPARATOR + value);
+                    } else {
+                        curEvent[fields.description] = this.getFormattedString(value);
+                    }
+                    break;
+                case 'ISREADONLY':
+                    curEvent[fields.isReadonly] = (value.indexOf('true') > -1);
+                    break;
+                case 'RRULE':
+                    curEvent[fields.recurrenceRule] = value;
+                    break;
+                default:
+                    if (this.parent.resourceCollection.length > 0) {
+                        const resData: Record<string, any>[] =
+                                this.parent.resourceCollection.filter((data: Record<string, any>) => data.field === type);
+                        curEvent[`${type}`] = (resData.length > 0 && (typeof (resData[0].dataSource[0][resData[0].idField]) == 'number')) ? parseInt(value, 10) : value;
+                    } else {
+                        curEvent[`${type}`] = value;
+                    }
+                }
+            }
+        }
+        return { isEvent, curEvent, id, count, events, key };
+    }
+
+    private processOccurrence(app: Record<string, any>[], maxId: number | string): Record<string, any>[] {
+        const appoint: Record<string, any>[] = [];
+        const uId: string = 'UID';
+        const fields: EventFieldsMapping = this.parent.eventFields;
+        const appointmentIds: number[] = [];
+        this.parent.eventsData.forEach((eventObj: Record<string, any>) => {
+            appointmentIds.push(eventObj[fields.id]);
+        });
+        app.forEach((eventObj: Record<string, any>) => {
+            let parentObj: Record<string, any>;
+            let id: number | string;
+            // eslint-disable-next-line no-prototype-builtins
+            if (!eventObj.hasOwnProperty(fields.recurrenceID)) {
+                parentObj = eventObj;
+                id = eventObj[fields.id] as string;
+            }
+            if (appointmentIds.indexOf(eventObj[fields.id]) < 0) {
+                const data: Record<string, any>[] = app.filter((data: Record<string, any>) => data.UID === eventObj[`${uId}`]);
+                if (data.length > 1 && isNullOrUndefined(eventObj[fields.recurrenceID])) {
+                    id = typeof (maxId) === 'number' ? maxId++ : id;
+                    for (let i: number = 0; i < data.length; i++) {
+                        // eslint-disable-next-line no-prototype-builtins
+                        if (data[parseInt(i.toString(), 10)].hasOwnProperty(fields.recurrenceID)) {
+                            const exdate: string = data[parseInt(i.toString(), 10)][fields.recurrenceID] as string;
+                            data[parseInt(i.toString(), 10)][fields.id] = typeof (maxId) === 'number' ? maxId++ : this.parent.eventBase.generateGuid();
+                            data[parseInt(i.toString(), 10)][fields.recurrenceID] = id;
+                            data[parseInt(i.toString(), 10)][fields.recurrenceException] = null;
+                            parentObj[fields.recurrenceException] =
+                                this.getExcludeDateString(parentObj[fields.recurrenceException], exdate);
+                            delete data[parseInt(i.toString(), 10)][`${uId}`];
+                            appoint.push(data[parseInt(i.toString(), 10)]);
+                        }
+                    }
+                    delete parentObj[`${uId}`];
+                    parentObj[fields.id] = id;
+                    appoint.push(parentObj);
+                    // eslint-disable-next-line no-prototype-builtins
+                } else if (!eventObj.hasOwnProperty(fields.recurrenceID)) {
+                    delete eventObj[`${uId}`];
+                    eventObj[fields.id] = typeof (maxId) === 'number' ? maxId++ : id;
+                    appoint.push(eventObj);
+                }
+            }
+        });
+        return appoint;
+    }
+
+    private getExcludeDateString(parentException: string, occurrenceException: string): string {
+        if (isNullOrUndefined(parentException)) {
+            return occurrenceException;
+        } else if (isNullOrUndefined(occurrenceException)) {
+            return parentException;
+        }
+        const parentExDate: string[] = parentException.split(',').map((x: string) => x.split('T')[0]);
+        const childExDate: string[] = occurrenceException.split(',').map((x: string) => x.split('T')[0]);
+        const exDate: string[] = parentExDate.filter((x: string) => childExDate.indexOf(x) > -1);
+        if (exDate.length > 0) {
+            return parentException;
+        }
+        return parentException + ',' + occurrenceException;
+    }
+
+    private getFormattedString(value: string): string {
+        value = value || '';
+        // eslint-disable-next-line no-useless-escape
+        return (value.replace(/\\\,/g, ',').replace(/\\\;/g, ';').replace(/\\[nN]/g, '\n').replace(/\\\\/g, '\\'));
+    }
+
+    private dateParsing(element: string): Date {
+        const split: string[] = element.split(':');
+        const value: string = split[split.length - 1];
+        let newDate: Date = new Date(this.getFormattedString(value));
+        if (element && (element.indexOf('VALUE=DATE') > -1 || element.indexOf('RECURRENCE-ID;TZID') > -1)) {
+            const data: string[] = /^(\d{4})(\d{2})(\d{2})$/.exec(value);
+            if (data !== null) {
+                newDate = new Date(parseInt(data[1], 10), parseInt(data[2], 10) - 1, parseInt(data[3], 10));
+            }
+            if (element.indexOf('DTSTART') > -1) {
+                this.allDay = true;
+            }
+        }
+        const data: string[] = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z)?$/.exec(value);
+        if (data !== null) {
+            if (data[7] === 'Z') {
+                newDate = new Date(Date.UTC(
+                    parseInt(data[1], 10),
+                    parseInt(data[2], 10) - 1,
+                    parseInt(data[3], 10),
+                    parseInt(data[4], 10),
+                    parseInt(data[5], 10),
+                    parseInt(data[6], 10)
+                ));
+            } else {
+                newDate = new Date(
+                    parseInt(data[1], 10),
+                    parseInt(data[2], 10) - 1,
+                    parseInt(data[3], 10),
+                    parseInt(data[4], 10),
+                    parseInt(data[5], 10),
+                    parseInt(data[6], 10)
+                );
+            }
+        }
+        return newDate;
+    }
+
+    protected getModuleName(): string {
+        return 'iCalendarImport';
+    }
+
+    public destroy(): void {
+        if (!this.parent || this.parent && this.parent.isDestroyed) { return; }
+    }
+
+}

package/dist/ts/schedule/exports/excel-export.d.ts

@@ -0,0 +1,14 @@
+import { Schedule } from '../base/schedule';
+import { ExportOptions } from '../base/interface';
+/**
+ * Excel Export Module
+ */
+export declare class ExcelExport {
+    private parent;
+    constructor(parent: Schedule);
+    initializeExcelExport(excelExportOptions?: ExportOptions): void;
+    private processWorkbook;
+    private getExportColumns;
+    protected getModuleName(): string;
+    destroy(): void;
+}

package/dist/ts/schedule/exports/excel-export.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Workbook, Worksheet, Worksheets, Column } from '@syncfusion/ej2-excel-export';
+import { Schedule } from '../base/schedule';
+import { ExcelFormat } from '../base/type';
+import { ExcelExportEventArgs, ExportFieldInfo, ExportOptions } from '../base/interface';
+import { extend, isNullOrUndefined } from '@syncfusion/ej2-base';
+import * as events from '../base/constant';
+
+/**
+ * Excel Export Module
+ */
+
+export class ExcelExport {
+    private parent: Schedule;
+
+    constructor(parent: Schedule) {
+        this.parent = parent;
+    }
+
+    public initializeExcelExport(excelExportOptions: ExportOptions = {}): void {
+        const exportColumns: ExportFieldInfo[] = this.getExportColumns(excelExportOptions);
+        const exportName: string = excelExportOptions.fileName || 'Schedule';
+        const exportType: ExcelFormat = excelExportOptions.exportType || 'xlsx';
+        const isIncludeOccurrences: boolean = excelExportOptions.includeOccurrences || false;
+        let separator: string;
+        if (!isNullOrUndefined(excelExportOptions.separator) && excelExportOptions.separator !== ',') {
+            separator = excelExportOptions.separator;
+        }
+        let eventCollection: Record<string, any>[];
+        if (excelExportOptions.customData) {
+            eventCollection = !isIncludeOccurrences ? excelExportOptions.customData :
+                this.parent.eventBase.getProcessedEvents(excelExportOptions.customData);
+        } else {
+            eventCollection = !isIncludeOccurrences ? this.parent.eventsData : this.parent.eventsProcessed;
+        }
+        this.processWorkbook(exportColumns, exportName, exportType, eventCollection, separator);
+    }
+
+    private processWorkbook(fields: ExportFieldInfo[], name: string, type: ExcelFormat, eventCollection: Record<string, any>[],
+                            separator: string): void {
+        const columns: Column[] = [];
+        const rows: Record<string, any>[] = [];
+        const columnHeader: Record<string, any>[] = [];
+        fields.forEach((field: ExportFieldInfo, i: number) => { columns.push({ index: i + 1, width: (field.name === 'Id' ? 50 : 150) }); });
+        const style: Record<string, any> = { fontSize: 12, borders: { color: '#E0E0E0' }, bold: true };
+        fields.forEach((field: ExportFieldInfo, i: number) => { columnHeader.push({ index: i + 1, value: field.text, style: style }); });
+        rows.push({ index: 1, cells: columnHeader });
+        eventCollection.forEach((event: Record<string, any>, i: number) => {
+            const columnData: Record<string, any>[] = [];
+            fields.forEach((field: ExportFieldInfo, n: number) => {
+                let columnRule: Record<string, any> = { index: n + 1, value: event[field.name] || '' };
+                if (field.name === this.parent.eventFields.startTime || field.name === this.parent.eventFields.endTime) {
+                    const styleRule: Record<string, any> = { fontSize: 12, numberFormat: 'm/d/yyyy h:mm a' };
+                    columnRule = extend({}, columnRule, { style: styleRule }, true) as Record<string, any>;
+                }
+                columnData.push(columnRule);
+            });
+            rows.push({ index: i + 2, cells: columnData });
+        });
+        const workSheet: Worksheets = [{ columns: columns, rows: rows } as Worksheet];
+        const args: ExcelExportEventArgs = { cancel: false, worksheets: workSheet };
+        this.parent.trigger(events.excelExport, args, (args: ExcelExportEventArgs) => {
+            if (args.cancel) {
+                return;
+            }
+            const book: Workbook = new Workbook({ worksheets: args.worksheets }, type, this.parent.locale, undefined, separator);
+            book.save(name + '.' + type);
+        });
+    }
+
+    private getExportColumns(exportOptions: ExportOptions): ExportFieldInfo[] {
+        const exportColumns: ExportFieldInfo[] = exportOptions.fieldsInfo || [];
+        if (exportColumns.length === 0) {
+            const fields: string[] = exportOptions.fields || Object.keys(this.parent.eventFields).map((field: string) =>
+                (<Record<string, any>>this.parent.eventFields)[`${field}`]) as string[];
+            fields.forEach((field: string) => { exportColumns.push({ name: field, text: field }); });
+        }
+        return exportColumns;
+    }
+
+    protected getModuleName(): string {
+        return 'excelExport';
+    }
+
+    public destroy(): void {
+        this.parent = null;
+    }
+
+}

package/dist/ts/schedule/exports/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exporting modules
+ */
+export * from './calendar-export';
+export * from './calendar-import';
+export * from './excel-export';
+export * from './print';

package/dist/ts/schedule/exports/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Exporting modules
+ */
+export * from './calendar-export';
+export * from './calendar-import';
+export * from './excel-export';
+export * from './print';

package/dist/ts/schedule/exports/print.d.ts

@@ -0,0 +1,20 @@
+import { Schedule } from '../base/schedule';
+import { ScheduleModel } from '../base/schedule-model';
+/**
+ * Print Module
+ */
+export declare class Print {
+    private parent;
+    private printInstance;
+    private printWindow;
+    constructor(parent: Schedule);
+    print(printOptions?: ScheduleModel): void;
+    private printScheduler;
+    private printSchedulerWithModel;
+    private getPrintScheduleModel;
+    private contentReady;
+    private closePrintWindow;
+    private printCleanup;
+    protected getModuleName(): string;
+    destroy(): void;
+}